Proyecto BlogZf – Parte 6

Published: January 12, 2009Posted in: Zend Framework, blogzfTags: , ,
Proyecto BlogZf – Parte 6

Plugins.

En ZF podemos utilizar plugins. Estos plugins se van a ejecutar en determinado momento, como puede ser el Predispatch o el PostDispatch. En muchos proyectos con ZF se utiliza una capa superior para los controllers para obligar al sistema que ejecute siempre la capa superior donde en esta capa podemos tener varias funcionalidades comunes para todos los controllers.

Esto no es una mala decisión, de hecho en nuestro blog tenemos un controller genérico. Pero también podemos hacer uso de los plugins, estos además de servirnos posteriormente para extender la funcionalidades, como puede ser el agregado de un contador de visitas, o cualquier funcionalidad extra que queramos darle al sistema sin necesidad de tocar el código existente, solo extendiendo el que hay. Como es el caso de los plugins en Wordpress, también podemos tener algunos plugins genéricos, para que procesen acciones genéricas, como puede ser el caso de configurar la vista, el layout, o la base de datos, el manejo de sesiones, etc.

En nuestro blog actualmente hay varios plugins, y cada uno bien separado su funcionalidad, hay un plugin extra especialmente para el admin, el cual maneja la seguridad (por ahora solo eso), pero también tenemos un plugin para instanciar la vista, y decirle de donde sacar el menú, y todo lo necesario para renderear la vista, además de un plugin para el manejo de layouts, otro plugin para la base de datos. Y además de esto una capa de abstracción superior en los controllers.

El uso de plugins en Zend Framework, es muy fácil y se cargan desde el bootstrap, cuando agregamos los controllers y antes de hacer dispatch, le decimos que plugins cargar.

  1.  
  2. <?php
  3. $controller = Zend_Controller_Front::getInstance
  4.     ->throwExceptions(true)
  5.     ->registerPlugin( new Blogzf_Controller_Plugin_Config())
  6.     ->registerPlugin( new Blogzf_Controller_Plugin_Layout())
  7.     ->registerPlugin( new Blogzf_Controller_Plugin_View())
  8.     ->registerPlugin( new Blogzf_Controller_Plugin_Backoffice())
  9.     ->dispatch();
  10. ?>
  11.  

Como se puede apreciar en el código de nuestro bootstrap, cargamos 4 plugins. Estos plugins los ubicamos en la carpeta library/Blogzf/Controller/Plugin, esta ruta es para tener una hegemonía con la estructura de directorios de ZF.

Estos plugins son muy fácil de programar. Cada clase implementa una interfaz genérica que cada método corresponde a una instancia de ejecución de nuestra pagina. Tenemos un método para preDispatch, otro para el postdispatch, que cada vez que le toca ejecutarse a estos metodos se llama a los plugins, antes del controller. Nuestros plugins extienden de la clase padre Zend_Controller_Plugin_Abstract . Un plugin normal con dos metodos como son PreDispatch, PostDispatch, quedaría como el siguiente.

  1.  
  2. <?php
  3. /**
  4.  * Plugin para administrar las vistas de nuestro sistema.
  5.  *
  6.  */
  7. class Blogzf_Controller_Plugin_View extends Zend_Controller_Plugin_Abstract
  8. {
  9.     protected $_viewRenderer;
  10.     protected $_view;
  11.     public function preDispatch (Zend_Controller_Request_Abstract $request)
  12.     {
  13.         /**
  14.          * Esto es un singleton de la vista para que no lo reinicie
  15.          */
  16.         $this->_viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(‘viewRenderer’);
  17.         $this->_viewRenderer->initView();
  18.         /**
  19.          * Traemo los datos del archivo de configuaracion
  20.          */
  21.         $config = Zend_Registry::getInstance()->get( ‘config_ini’ );
  22.         $auth = Zend_Auth::getInstance();
  23.        
  24.         $this->_view = $this->_viewRenderer->view;
  25.        
  26.         /**
  27.          * Agregamos unas
  28.          */
  29.         $this->_view->baseUrl = $request->getBaseUrl();
  30.         $this->_view->module = $request->getModuleName();
  31.         $this->_view->controller = $request->getControllerName();
  32.         $this->_view->action = $request->getActionName();
  33.  
  34.         $this->_view->hasIdentity = false;
  35.        
  36.         if ( $auth->hasIdentity() ) {
  37.             $this->_view->hasIdentity = true;
  38.             $this->_view->Identity = $auth->getIdentity();
  39.         }
  40.        
  41.         /**
  42.          * Agregamos las rutas para las vistas
  43.          */
  44.         $this->_view->addScriptPath(‘/application/blog/views’);
  45.         $this->_view->addScriptPath(‘/application/admin/views’);
  46.         /**
  47.          * Url basicas del sistema
  48.          */
  49.         $this->_view->staticServer = $config->site->static->server;
  50.         $this->_view->appServer = $config->site->static->server;
  51.          /**
  52.          * Agrego el titulo de la pagina
  53.          */
  54.         $this->_view->headTitle()->append( $config->site->title );
  55.         $this->_view->site = $config->site;
  56.         /**
  57.          * Agrego los css para esta pagina que siempre va a ser el mismo.
  58.          * /layout/nombre_layout/style.css esto es para poder agregar muchos layout. Y no dependan
  59.          * de la cantidad de css, si necesitamos separar en mas archivos. Podemos hacer un @import desde
  60.          * style.css
  61.          *
  62.          */
  63.         if ( $request->module == ‘admin’ ) {
  64.             $layout = $config->site->layout->admin;
  65.             $this->_view->headScript()
  66.                 ->appendFile( $this->_view->staticServer . ‘js/mootools/mootools-core.js’ );
  67.         } else {
  68.             $layout = $config->site->layout->default;
  69.         }
  70.  
  71.         $this->_view->headLink()
  72.             ->appendStylesheet( $this->_view->staticServer . ‘layout/’.$layout.‘/styles.css’ );
  73.  
  74.  
  75.     }
  76.     public function postDispatch (Zend_Controller_Request_Abstract $request)
  77.     {
  78.         if ($this->_view->module==‘default’) {
  79.             return;
  80.         }
  81.          
  82.         if ($this->_view->layout()->isEnabled() ) {
  83.             $this->_view->layout()->sidebar = $this->_view->action( ‘rightcontent’, ’sidebar’, $this->_view->module );
  84.             $this->_view->layout()->header = $this->_view->action( ‘header’, ’sidebar’, $this->_view->module );
  85.             $this->_view->layout()->footer = $this->_view->action( ‘footer’, ’sidebar’, $this->_view->module );
  86.             $this->_view->layout()->menutop = $this->_view->action( ‘menutop’,’sidebar’, $this->_view->module );
  87.         }    
  88.     }
  89. }
  90.  

Si necesitamos que algun dato persista, podemos usar Zend_Registry ;)

Como se daran cuenta, estos plugins son muy facil. No requieren mucho mas que esto.

Si van al codigo de blogzf van a encontrar el codigo de los otros 4 plugins.

Mas informacion