Arquivos de configuração do Zend Framework 2

imagem-arquivos-configuracao-zend-framework-2

Confesso que comecei a escrever um post sobre “Como criar um módulo novo no ZF2”, mas acabei travando na hora de configurar este módulo. Os arquivos de configuração do Zend Framework 2 podem parecer um tanto quanto complicados se simplesmente jogados assim ao léu. Também não adianta eu criar um tutorial pra ajudar o pessoal se apenas jogar o código na tela e falar “copia, cola, e roda!”. Acho que é necessário um entendimento do que se está fazendo, para facilitar as manutenções e também para diminuir o tempo com debugs e testes.

Vou apresentar agora, de forma bem simples e mais clara possível, os arquivos de configuração do Zend Framework.

 

imagem-arquivo-configuracao-global

Arquivo de configuração global

Há um arquivo no Zend Framework 2 que é o principal responsável pela configuração de toda a aplicação. Levando em conta que você tem a mesma base que começamos a trabalhar nos dois primeiros tutoriais desta série ( Rodar o Zend Framework pela primeira vez e Estrutura do Zend Framework 2 ), acesse o diretório zf2/config e abra o arquivo “application.config.php”.

Neste arquivo de configuração à nível de aplicação (mais adiante veremos o arquivo à nível de módulo), temos um array com diversas chaves e valores.

Veja o código presente no arquivo:

<?php
return array(
    'modules' => array(
        'Application',
    ),
    'module_listener_options' => array(
        'module_paths' => array(
            './module',
            './vendor',
        ),
        'config_glob_paths' => array(
            'config/autoload/{,*.}{global,local}.php',
        ),
    ),
);

Perceba que este array está sendo retornado (com um “return”), e é no arquivo “zf2/public/index.php” (nosso Front Controller) que estamos chamando este arquivo, e consequentemente, todo esse array de configurações.

Acompanhe linha a linha:

Linha 2: retornamos o array definido a seguir.

Linha 3: definimos a chave ‘modules’, onde colocamos os módulos que deverão ser carregados pelo Zend Framework. Um módulo criado, configurado e não declarado aqui NÃO IRÁ FUNCIONAR!

Linha 7: definimos os diretórios principais que estes módulos vão carregar / ser carregados. Tudo será definido a partir dos diretórios ‘module’ e também do ‘vendor’.

Linha 11 e 12: carregamento dos arquivos locais e globais, definidos dentro do diretório ‘autoload’, no mesmo nível deste arquivo. Estes arquivos servem para carregamento de configurações de banco de dados, entre outras configurações.

 

Obs.: Por padrão, qualquer arquivo que termine com “local.php” será ignorado pelo git caso você o utilize. Por considerar configurações LOCAIS, ele vem previamente configurado para não ‘commitar’ as mudanças nesses arquivos.

Estas são as configurações básicas à nível de aplicação. Vamos dar uma olhada nas configurações à nível de módulos agora. Abra o arquivo “zf2/module/Application/config/module.config.php”.

 

imagem-rotas-zend-framework-2

Rotas do Zend Framework

No Zend Framework 2 a navegação e as URLs amigáveis são possíveis graças as configurações de rota.

Como vamos falar agora das rotas, foque das linhas de número 3 até a número 42 do arquivo “module.config.php”. Veja que há uma porção de arrays brotando de outros arrays. Chega a ser um pouco confuso de se encontrar em meio a tanto abre e fecha parênteses, mas não se preocupe, vamos analisar esta parte bem devagar. Veja o trecho de código copiado abaixo:

'router' => array(
    'routes' => array(
        'home' => array(
            'type' => 'Zend\Mvc\Router\Http\Literal',
            'options' => array(
                'route'    => '/',
                'defaults' => array(
                    'controller' => 'Application\Controller\Index',
                    'action'     => 'index',
                ),
            ),
        ),
        'application' => array(
            'type'    => 'Literal',
            'options' => array(
                'route'    => '/application',
                'defaults' => array(
                    '__NAMESPACE__' => 'Application\Controller',
                    'controller'    => 'Index',
                    'action'        => 'index',
                ),
            ),
            'may_terminate' => true,
            'child_routes' => array(
                'default' => array(
                    'type'    => 'Segment',
                    'options' => array(
                        'route'    => '/[:controller[/:action]]',
                        'constraints' => array(
                            'controller' => '[a-zA-Z][a-zA-Z0-9_-]*',
                            'action'     => '[a-zA-Z][a-zA-Z0-9_-]*',
                        ),
                        'defaults' => array(
                        ),
                    ),
                ),
            ),
        ),
    ),
),

 

Análise linha a linha sobre o trecho copiado acima:

Linha 1: Iniciamos o array que indica o início da configuração das rotas.

Linha 2: Aqui abrimos o array que define as rotas da aplicação no Zend Framework 2

Linha 3: Definido o nome da primeira rota (home). Abre-se o array para configurações desta rota em específico.

Linha 4: Qual o tipo da rota? Neste caso, Literal. Conheça e entenda os tipos de rota existentes no ZF2 aqui – http://framework.zend.com/manual/2.0/en/modules/zend.mvc.routing.html

Linha 5: Abrimos o array com opções para esta rota

Linha 6: no valor de ‘route’, definimos o valor que será digitado na URI para cair nesta rota. Neste caso, basta o usuário acessar a raiz do projeto, por isto apenas uma barra ( / ) ali.

Linha 7: em ‘defaults’, definidos o que será carregado por padrão ao cair nesta rota. Perceba que nas linhas 8 e 9 definimos, respectivamente, o controller e a action que desejamos carregar.

Resumo até aqui: Quando o camarada acessar sua aplicação, sem passar nenhum parâmetro além da URL principal dela, ele cai nessa rota. Nela o Zend busca a action ‘index’ dentro do controller ‘Index’ e carrega este conteúdo para você visualizar.

Continuando…

Linha 13: abrimos uma nova rota chamada ‘application’. Perceba que ela tem como configuração inicial a mesma coisa da rota ‘home’, porém codificado um pouco diferente. Acredito que a Zend tenha feito isto para mostrar mais formas de configuração.

Linha 23: aqui temos algo novo. A rota (definida com URI ‘/application’ na linha 16) pode simplesmente não acabar aí. Portanto definimos algumas coisinhas a mais…

Linha 24: em ‘child_routes’, definimos configurações ‘filhas’ para a rota principal ( /application ).

Linha 26: definido tipo “Segment” para a rota.

Linha 27: em ‘options’ definimos as opções para a rota filha.

Linha 28: ‘route’ novamente. O que poderá aparecer nessa rota? Poderá aparecer um controller e uma action, respectivamente.

Linha 29: Abrimos as ‘constraints’ (restrições) e definimos logo a seguir o que pode ou não ser considerado nas variáveis ‘controller’ e ‘action’ em forma de expressão regular. Uma rápida leitura sobre expressões regulares irá facilitar um pouco seu compreendimento nesta parte. http://pt.wikipedia.org/wiki/Express%C3%A3o_regular

Resumindo até aqui: Leve em consideração que sua URL é “zf2.com.br”.

Acessando “zf2.com.br/” – caímos na primeira rota ( apenas o / ).

Acessando “zf2.com.br/application” – caímos na segunda rota ( /application )

Acessando “zf2.com.br/aplication/index” – caímos na filha da segunda rota ( /application é a rota principal e o /index diz respeito ao controller “Index”).

Acessando “zf2.com.br/aplication/index/index” – caímos na filha da segunda rota ( /application é a rota principal, o primeiro /index diz respeito ao controller “Index” e o segundo /index diz respeito à action index.

Acho que neste ponto seria interessante você executar alguns testes sobre estas rotas. Experimente trocar o nome da action INDEX (alterando também o nome de seu arquivo .phtml no diretório “view/application/index” e veja até onde suas URIs vão funcionar conforme o exemplo acima.

 
 

zend-framework-controllers

Configuração dos Controllers

 

Até o momento, temos apenas um controller criado em nossa aplicação. Mas mesmo que fossemos lá e criássemos mais um controller ele não iria funcionar. Sabe por quê? A Zend levou extremamente a sério a questão de “deixar tudo explícito” e até mesmo os controllers que não forem declarados não funcionarão. Um pouco incômodo? Talvez, para projetos em que muitos controllers são criados. Porém isto permite um controle maior sobre a aplicação, portanto é válido. Ressalto também que módulos com muitos controllers devem ser repensados, uma vez que possivelmente estamos agregando muitas funções sobre um módulo só e perdendo o sentido “modular” do Zend Framework. Uma refatorada aqui, talvez uma repensada na arquitetura alí, e é bem possível que estes controllers sejam reduzidos, ou divididos em novos módulos.

Mas onde eu devo declarar os controllers que eu criar? Fácil. No próprio arquivo module.config.php, foque-se agora nas linhas 43 à 47. Veja abaixo:

'controllers' => array(
        'invokables' => array(
            'Application\Controller\Index' => 'Application\Controller\IndexController'
        ),
    ),

Linha a linha:

Linha 2: abrimos o array que define os controllers que podem ser “invocados” pelo framework.

Linha 3: definimos uma referencia para o controller como chave, e como valor o nome (com namespace) do próprio. Como esta referência deve ser única em todos os módulos, colocamos a mesma com o namespace do módulo também (apenas boa prática, não obrigatório)

 

Agora vamos falar do trecho do código das linhas 48 à 63, veja abaixo:

'view_manager' => array(
        'display_not_found_reason' => true,
        'display_exceptions'       => true,
        'doctype'                  => 'HTML5',
        'not_found_template'       => 'error/404',
        'exception_template'       => 'error/index',
        'template_map' => array(
            'layout/layout'           => __DIR__ . '/../view/layout/layout.phtml',
            'application/index/index' => __DIR__ . '/../view/application/index/index.phtml',
            'error/404'               => __DIR__ . '/../view/error/404.phtml',
            'error/index'             => __DIR__ . '/../view/error/index.phtml',
        ),
        'template_path_stack' => array(
            __DIR__ . '/../view',
        ),
    ),

Analisando o código linha a linha…

Linha 1: Abrimos o array com as configurações da camada de visualização

Linha 2 e 3: Define-se algumas coisas que serão mostradas para o usuário na tela.

Linha 4: Define-se o DOCTYPE da página. Perceba que ele vem pré-configurado com ‘HTML5’

Linha 5: Define-se o template para casos do famoso ‘Erro 404’

Linha 6: Define-se o template para casos onde ocorra uma ‘exception’

Linha 7: Abrimos o array para mapear os templates

Linha 8: Define-se aqui o caminho para o arquivo do layout do módulo (arquivo com cabeçalho, menu, rodapé, enfim, o que você desejar que se repita nas páginas)

Linha 9: Define-se o caminho da página padrão do módulo.

Linha 10: Define-se o caminho do arquivo para o template de erro 404.

Linha 11: A mesma definição, porém agora para o arquivo de exceções (exceptions)

Linha 14: Instrui o framework em qual diretório ele deve procurar os templates definidos acima e também todos os arquivos da camada de visualização.
 

Pronto, terminamos a análise do arquivo de configuração à nível de módulo. Vamos conhecer agora o nosso principal arquivo dentro de um módulo: Module.php .

 
 

modulo-zend-framework

Arquivo Module.php

 

O arquivo Module.php está localizado em “zf2/module/Application/”. Abra-o e repare no seguinte código:

<?php

namespace Application;

use Zend\Mvc\ModuleRouteListener;
use Zend\Mvc\MvcEvent;

class Module
{
    public function onBootstrap(MvcEvent $e)
    {
        $eventManager        = $e->getApplication()->getEventManager();
        $moduleRouteListener = new ModuleRouteListener();
        $moduleRouteListener->attach($eventManager);
    }

    public function getConfig()
    {
        return include __DIR__ . '/config/module.config.php';
    }

    public function getAutoloaderConfig()
    {
        return array(
            'Zend\Loader\StandardAutoloader' => array(
                'namespaces' => array(
                    __NAMESPACE__ => __DIR__ . '/src/' . __NAMESPACE__,
                ),
            ),
        );
    }
}

Analisando-o linha a linha:

Linha 3: Definição do namespace.

Linha 5 e 6: Incluindo para uso duas classes do Framework (ModuleRouteListener, responsável por ficar controlando as rotas, e também o MvcEvent, responsável por cuidar dos Eventos)

Obs.: No Zend Framework, todos os processos são orientados à eventos. Iniciar, renderizar, despachar, encerrar, rotear.. estes são alguns deles, mas isto é assunto para outro tutorial.

Perceba a classe Module sendo criada na linha 8. Este nome para a classe (assim como para o arquivo) é obrigatório, não pode ser alterado.

Linha 10: função “onBootstrap”. O nome já diz. Ela é executada quando o módulo é requisitado. Assim como o index.php na pasta public é o front-controller para a aplicação como um todo, o arquivo Module.php é o front-controller para o módulo. Se você comentar esta função, o módulo continua funcionando, porém apenas com sua URL padrão. Rotas neste momento não irão funcionar, já que o conteúdo desta função é o responsável por ficar monitorando esta questão.

Linha 17: função “getConfig”. Mais uma que é auto-explicativa. Ela busca o arquivo de configuração do módulo e inclui na execução do mesmo.

Linha 22: função “getAutoloaderConfig”. Para facilitar o uso das classes no desenvolvimento, o autoload é empregado. Deixe esta função como está, pois ela providencia isto para você, desde que você respeite as regras para namespaces.

 
 

finalizando

Finalizando

 

Acredito que você compreendeu até este momento como funcionam as configurações básicas do Zend Framework 2, e portanto está apto para criar algo do zero. Vou encerrar este post por aqui, para não ficar muito extenso e nem cansativo, e em nosso próximo encontro vamos criar juntos um módulo simples, utilizando as configurações que vimos até o momento.

Um forte abraço a todos e nos falamos em breve! Ah, não esqueça de comentar logo abaixo informando se o artigo foi útil, e como posso melhorar para facilitar para todos! Escrever esses posts dá trabalho, mas a satisfação de ler comentários e saber que as pessoas estão avaliando o conteúdo compensa.


Marcado com: , ,
Publicado em Zend Framework 2
  • Arnaldo

    Muitíssimo obrigado por compartilhar seu conhecimento. Foram os melhores tutoriais que encontrei na Internet. Não faz ideia de como me ajudaram.

    obrigado

    • http://www.ricardobrusch.com.br Ricardo Brusch

      Que isso cara, eu que agradeço à ti por dedicar teu tempo lendo os tutoriais que escrevo. A ideia é essa mesma: compartilhar o conhecimento. Qualquer coisa que precisar e eu puder ajudar, estou a disposição! Um forte abraço e sucesso!

  • Ricardo Constantino Ferreira

    Muito bom esse tutorial, me ajudou muito a entender essas rotas.

    Parabéns

    • Ricardo Brusch

      Fala meu xará, obrigado pelo comentário. Toda crítica e sugestão é sempre bem vinda, porém um elogio é ainda melhor, hehehe. O ZF2 é um ótimo framework, porém as vezes ele é meio complicado mesmo (parece até a minha esposa, huahuahuahua).

      De qualquer forma, é uma ótima base para projetos de qualquer tamanho, fique a vontade para ler os outros tutoriais do ZF2 que tenho por aqui, tirar dúvidas e dar sugestões e dicas também! Um forte abraço, cara.

Volte Sempre!
Meus artigos te ajudaram de alguma forma e você não sabe como me agradecer? Que tal me pagar uma Coca-Cola bem gelada?

Sobre o autor

Me chamo Ricardo Brusch, sou programador e desenvolvedor de sistemas para internet. Também sou aspirante a escritor, e você pode ler alguns de meus contos malucos em contos.ricardobrusch.com.br.
Parceiros





Publicidade