Novembro 29th 2008 03:50 am

Injeção de dependência com Zend Framework

É comum ver por ai, as pessoas fazendo o setup da aplicação sempre no arquivo de bootstrap do Zend, algo do tipo:

arquivo: index.php

PHP:
  1. require_once 'Initializer.php';
  2. require_once 'Zend/Loader.php';
  3.  
  4. Zend_Loader::registerAutoload();
  5.  
  6. $frontController = Zend_Controller_Front::getInstance();
  7.  
  8. //inicializando configuração do banco de dados
  9. $db = new Zend_Db_Adapter_Oracle(array(
  10.     'username' => 'xxxxxx',
  11.     'password' => 'xxxxxx',
  12.     'dbname'   => 'xe'
  13. ));
  14.  
  15. Zend_Db_Table_Abstract::setDefaultAdapter($db);
  16.  
  17. //inicializando configuração de routes
  18. //...
  19.  
  20. // inicializando layout
  21. Zend_Layout::startMvc();
  22.  
  23. // inicializando componente tal ....
  24.  
  25. $frontController->addControllerDirectory(dirname(__FILE__) . '/application/default/controllers', 'default');
  26. $frontController->dispatch();

Porém, existem maneiras mais fáceis (e mais elegantes) de fazer isso. Injeção de Dependência é uma delas. Com o Zend Framework existem alguns pontos onde podemos aplicar este tipo de abordagem, utilizando Action Helpers, View Helpers e Plugins. Já expliquei aqui no blog como utilizar plugins, no post Não estenda. Plugue!.

O exemplo abaixo é uma alternativa para setup utilizando plugins, para os usuários do Zend Studio for Eclipse isso é talvez seja familiar, já que a IDE gera o projeto mais ou menos desta mesma forma.

Primeiro nosso plugin:

PHP:
  1. <?php
  2.  
  3. require_once 'Zend/Controller/Plugin/Abstract.php';
  4. require_once 'Zend/Controller/Front.php';
  5. require_once 'Zend/Controller/Request/Abstract.php';
  6. require_once 'Zend/Controller/Action/HelperBroker.php';
  7.  
  8. /**
  9.  * plugin de inicialização da aplicação
  10.  *
  11.  */
  12. class Initializer extends Zend_Controller_Plugin_Abstract
  13. {
  14.    
  15.     protected static $_config;
  16.  
  17.     protected $_env;
  18.  
  19.     protected $_front;
  20.  
  21.     protected $_root;
  22.  
  23.     /**
  24.      * Constructor
  25.      *
  26.      * inicializa configurações
  27.      *
  28.      * @param  string $env (development, test, production)
  29.      * @param  string|null $root
  30.      * @return void
  31.      */
  32.     public function __construct($env, $root = null)
  33.     {
  34.         $this->_setEnv($env);
  35.         if (null === $root) {
  36.             $root = realpath(dirname(__FILE__) . '/../');
  37.         }
  38.         $this->_root = $root;
  39.  
  40.         $this->_front = Zend_Controller_Front::getInstance();
  41.        
  42.         $this->initPhpConfig();
  43.     }
  44.  
  45.     /**
  46.      * seta ambiente
  47.      *
  48.      * @param  string $env
  49.      * @return void
  50.      */
  51.     protected function _setEnv($env)
  52.     {
  53.         $this->_env = $env;     
  54.     }
  55.    
  56.  
  57.     /**
  58.      * inicializa configurações do php
  59.      *
  60.      * @return void
  61.      */
  62.     public function initPhpConfig()
  63.     {
  64.         // seta parametros para ambiente de teste
  65.         if ($this->_env == 'test') {
  66.             // habilita todos os erros do php 
  67.             error_reporting(E_ALL | E_STRICT); 
  68.             ini_set('display_startup_errors', 1); 
  69.             ini_set('display_errors', 1);
  70.  
  71.             $this->_front->throwExceptions(true); 
  72.         }
  73.     }
  74.    
  75.     /**
  76.      * faz todas as inicializações antes do inicio do roteamento para os controllers
  77.      *
  78.      * @return void
  79.      */
  80.     public function routeStartup(Zend_Controller_Request_Abstract $request)
  81.     {
  82.         $this->initDb();
  83.         $this->initHelpers();
  84.         $this->initView();
  85.         $this->initPlugins();
  86.         $this->initRoutes();
  87.         $this->initControllers();
  88.     }
  89.    
  90.     /**
  91.      * inicializa banco de dados
  92.      *
  93.      * @return void
  94.      */
  95.     public function initDb()
  96.     {
  97.         $db = new Zend_Db_Adapter_Oracle(array(
  98.             'username' => 'xxxxx',
  99.             'password' => 'xxxxx',
  100.             'dbname'   => 'xe'
  101.         ));
  102.        
  103.         Zend_Db_Table_Abstract::setDefaultAdapter($db);
  104.     }
  105.  
  106.     /**
  107.      * inicializa os action helpers
  108.      *
  109.      * @return void
  110.      */
  111.     public function initHelpers()
  112.     {
  113.         Zend_Controller_Action_HelperBroker::addPath('../application/default/helpers', 'Zend_Controller_Action_Helper');
  114.     }
  115.    
  116.     /**
  117.      * inicializa o view
  118.      *
  119.      * @return void
  120.      */
  121.     public function initView()
  122.     {
  123.         Zend_Layout::startMvc(array(
  124.             'layoutPath' => $this->_root .  '/application/default/layouts',
  125.             'layout' => 'main'
  126.         ));
  127.        
  128.     }
  129.    
  130.     /**
  131.      * inicializa plugins
  132.      *
  133.      * @return void
  134.      */
  135.     public function initPlugins()
  136.     {
  137.     }
  138.    
  139.     /**
  140.      * inicializa routes
  141.      *
  142.      * @return void
  143.      */
  144.     public function initRoutes()
  145.     {
  146.     }
  147.  
  148.     /**
  149.      * inicializa os controllers
  150.      *
  151.      * @return void
  152.      */
  153.     public function initControllers()
  154.     {
  155.         $this->_front->addControllerDirectory($this->_root . '/application/default/controllers', 'default');
  156.     }
  157. }

Após isso, nosso arquivo de bootstrap:

PHP:
  1. require_once 'Initializer.php';
  2. require_once 'Zend/Loader.php';
  3.  
  4. Zend_Loader::registerAutoload();
  5.  
  6. $frontController = Zend_Controller_Front::getInstance();
  7. $frontController->registerPlugin(new Initializer('development'));
  8. $frontController->dispatch();

Dessa forma criamos as rotinas de setup e deixamos que o próprio Zend inicialize as coisas para nós.

[]s

Compartilhe:
  • del.icio.us
  • Google
  • Digg
  • Sphinn
  • Facebook
  • Mixx
  • LinkedIn
  • Live
  • Rec6
  • Technorati
  • TwitThis
1 Estrela2 Estrela3 Estrela4 Estrela5 Estrela (Nenhuma avaliação ainda)
Loading ... Loading ...

3 Comments »

3 Responses to “Injeção de dependência com Zend Framework”

  1. Bruno Viana on 02 Dez 2008 at 14:14 #

    Hm… muito bom! Sempre tive duvidas do que seria Injeção de Dependencia mas deu pra entender melhor agora!

    Não sei se lembra de mim, estava no mesmo taxi que vc voltando da PHP Conf.. hehehe

    Abração!

  2. Diego Tremper on 02 Dez 2008 at 20:58 #

    Lembro sim, tava meio dormindo mais lembro..hehe
    Abraço!

  3. Arian Maykon (Dead_Thinker) on 16 Jan 2009 at 21:40 #

    Bem interessante, não sabia que era aplicado o conceito de injeção de dependência ai.

    Uma abordagem parecida é a do Padraic no sistema de blog dele, o Bootstrapper.php.

Trackback URI | Comments RSS

Leave a Reply

« Validação de CNPJ utilizando Zend_Validate | Palestra no PHPConference 2008 »