Introducción a Zend Framework, un poderoso framework que nos ayudará a reducir nuestro tiempo de desarrollo además de integrar diferentes api’s de distintos sitios como google o flickr haciendo nuestro trabajo más fácil y rápido.

Autor:

Hola! soy Eric de Perú. Desarrollo en PHP desde hace 10 años aunque también manejo C++ y Java. Trabajo para una empresa de eventos de juegos pero también ejerzo de freelance. Puedes seguirme en mi twitter.
Descarga Demostración

Introducción a Zend Framework

Zend Framework está desarrollado en php con el afán de hacer el trabajo de los programadores más simple y amistoso. Está hecho basado en la programación orientada a objetos pensando en hacer aplicaciones más seguras orientadas a la web 2.0 y a los web services, utilizando el patrón MVC.

Para ello han desarrollado diferentes API’s para servicios populares como Flickr, Google, etc entre otros y han integrado frameworks javascript como Dojo Toolkit y jQuery.

ZF está disponible en http://framework.zend.com de forma gratuita. Se instala desempaquetando el archivo comprimido en la ruta en la que estará nuestro host.

Estructura de carpetas

La estructura básica de carpetas de ZF es la siguiente:

-home/
--- application/
----- config/
----- controllers/
------- ErrorController.php
------- IndexController.php
----- models/
----- views/
------- scripts/
--------- index/
----------- index.phtml
----- Bootstrap.php
--- library/
------ Zend
--- www/

Analicemos la estructura:

  • En application, irá en si la aplicación que realizaremos.
  • En library, irá la librería de Zend (es la que desempaquetamos).
  • www es la caperta expuesta a internet. En ella almacenaremos los js, imágenes, css, y principalmente nuestro archivo index.php.

Esta vez usaremos ZF bajo la convención modular, esto quiere decir que nuestra aplicación crecerá por módulos, lo que hace que sea más escalable y portátil.

¿Cómo? Cada módulo es una miniaplicación, permitiéndonos reutilizarla en diferentes proyectos sin realizar mucho trabajo de adaptación.

Con ello la estructura de la carpeta application sería así:

-application/
--- config/
--- modules/
----- default/
------- controllers/
--------- ErrorController.php
--------- IndexController.php
------- views/
--------- scripts/
----------- error/
------------- error.phtml
----------- index/
------------- index.phtml
----- blog/
------- controllers/
--------- IndexController.php
------- views/
--------- scripts/
----------- index/
------------- index.phtml
------- Bootstrap.php <== del módulo
--- Bootstrap.php <== de la aplicación

Lo primero que podemos ver es que en el ejemplo, existe una carpeta modules y dentro de ella hay dos módulos: default y news.

Como mencioné antes, cada módulo es una miniaplicación, lo que significa que cada uno tendrá una configuración independiente. Siempre usando el patrón MVC. El módulo por defecto es default. Este es el primero en ejecutarse, es decir que nuestro homepage estará ubicado en este.

La aplicación tiene un arrancador general, que es el archivo Bootstrap.php, en el que se indica cómo funcionará, por ejemplo, las rutas, el caché, la base de datos, etc. Como cada módulo es una miniaplicacion, cada uno uno debe llevar un archivo Bootstrap.php también, excepto el módulo default que usará el de la aplicación en sí.

Configuración Básica

Veamos ahora cómo se programa la aplicación en lo más básico…

Nuesto nuevo index.php

El archivo index.php es de lo más simple. Solo tenemos que declarar la ruta del Zend y ejecutar la aplicación. Sería algo así:

<php
DEFINE('ROOT_PATH', dirname(dirname(__FILE__)).'/');
DEFINED('APPLICATION_ENV') || DEFINE('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));

set_include_path(implode(PATH_SEPARATOR, array(ROOT_PATH.'library/', get_include_path())));
 
require_once 'Zend/Application.php'; 
$application = new Zend_Application(
 APPLICATION_ENV,
 APPLICATION_PATH . 'config/application.ini'
);
$application->bootstrap()
 ->run();
?>

La configuración de la aplicación: application.ini

Hay un archivo config/application.ini en el que se guarda la configuración inicial de la aplicación. Es muy sencillo. Sería así:

[production]
;error
 phpSettings.display_startup_errors      = 0
 phpSettings.display_errors              = 0
;include path
    includePaths.library              = LIBRARY_PATH
;bootstrap
    bootstrap.path                    = ROOT_PATH "application/Bootstrap.php"
    bootstrap.class                   = "Bootstrap"
;resources.frontController
    resources.frontController.moduleDirectory = ROOT_PATH "application/modules"
    resources.frontController.moduleControllerDirectoryName   = "controllers"
    resources.frontController.defaultModule                   = "default"
    resources.frontController.defaultControllerName           = "index"
    resources.frontController.defaultAction                   = "index"
;convencion modular
    resources.modules                       =
;resources.db
    resources.db.adapter                    = "pdo_mysql"
    resources.db.params.host                = "localhost"
    resources.db.params.username            = "usuario_produccion"
    resources.db.params.password            = "hhjj"
    resources.db.params.dbname              = "news"
    resources.db.isDefaultTableAdapter      = true

[development : production]
    phpSettings.display_startup_errors      = 1
    phpSettings.display_errors              = 1
    resources.db.params.username            = "usuario_desarrollo"
    resources.db.params.password            = "nnmm"
    resources.db.params.dbname              = "news_desarrollo"

¿Qué significa todo esto? En ZF se utilizan cuatro estados de trabajo:

  • [production]
  • [staging : production]
  • [testing : production]
  • [development : production]

Los estados staging, testing y development, heredarán las configuraciones de production, excepto los hayamos reescrito como en el ejemplo anterior con la base de datos. Es útil porque podemos pasar de un estado en desarrollo a otro en producción con tan solo declararlo en el index.php sin tener que volver a escribir las nuevas configuraciones.

En application.ini, podemos definir, los errores, el include_path(importantísimo para toda la aplicación), el bootstrap(se encargará de inicializar el resto de la aplicación), los layouts, el froncontroller, la base de datos, y la configuración de las vistas, etc.

Es decir, definimos la configuración del php que usaremos, el bootstrap, los recursos y los plugins.

El arracandor de ZF: el Bootstrap

El Bootstrap.php de la aplicación hereda de Zend_Application_Bootstrap_Bootstrap mientras que el de los módulos hereda de Zend_Application_Module_Bootstrap. Ambos pueden realizar las mismas tareas.

En el Bootstrap, todas las funciones que empiezen por _init se ejecutan automáticamente. Estas tienen que ser protected.

<?php
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initView()
    {
        $view = new Zend_View();
        $view->doctype('XHTML1_STRICT');  
        $view->headTitle()->setSeparator(' :: ')->append('Mi sitio');
        $view->headMeta()->appendHttpEquiv('Content-Type',
                                           'text/html; charset=utf-8')
                         ->appendHttpEquiv('expires', '0')
                         ->appendHttpEquiv('pragma', 'no-cache')
                         ->appendHttpEquiv('Cache-Control', 'no-cache');
        $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(
           'ViewRenderer'
        );
        $viewRenderer->setView($view);
        return $view;
    }
}
?>

Los controladores

El IndexController.php sería como sigue:

<?php
class IndexController extends Zend_Controller_Action
{   
    public function indexAction()
    {
        $this->view->headTitle('Mi aplicación');
        $this->view->mensaje = $this->mensaje();
    }
 
    private function mensaje()
    {
         return 'qué tal mi aplicación en ontuts??';
 
     }
}
?>

Para los controladores de los módulos, tenemos que indicar la ruta en el nombre de la clase, así:

class News_IndexController extends Zend_Controller_Action

Las vistas

Debemos tener en cuenta que cada función que termine en Action, necesita un archivo .phtml con el mismo nombre. Por ejemplo indexAction() estará relacionado con index.phtml.

También podriamos indicarle que utilice otra vista o no que simplemente no tenga ninguna. La vista para este ejemplo sería index.phtml:

<?php echo $this->doctype(); ?>
<html>
<head>
    <?php echo $this->headMeta(); ?>
    <?php echo $this->headTitle(); ?>
    <?php echo $this->headStyle(); ?>
    <?php echo $this->headScript(); ?>
</head>

<body>
    <?php echo $this->mensaje; ?>
    <br />
    que tal mi aplicacion en ontuts :P 
</body>
</html>

La página de error

Antes de ejecutar nuestra aplicación debemos saber que ZF nos pide que tengamos una página de error. De tal manera que ahora sí, podremos no nos olvidaremos de hacer nuestra propia página de error y podremos conocer cuál es, 404 o 505 o el que fuere y así poder darle al usuario final una mejor orientación de que hacer.

Es importante tener en cuenta que sin el controlador ErrorController.php la aplicación no funcionará.

Tenemos que hacer una clase ErrorController y guardarla en el módulo default. En realidad se maneja igual que cualquier otro controlador y su vista. El método usado dentro de ErrorController deberá ser errorAction, el ErrorController.php quedaría asi:

<?php
class ErrorController extends Zend_Application_Action {
	public function errorAction()
	{
	}
}
?>

Y su vista sería asi (error.phtml):

<?php echo $this->doctype(); ?>
<html>
<head>
    <?php echo $this->headMeta(); ?>
    <?php echo $this->headTitle(); ?>
    <?php echo $this->headStyle(); ?>
    <?php echo $this->headScript(); ?>
</head>

<body>
    Error 404
    La página no existe!
</body>
</html>

Y eso es todo… hasta aquí por hoy :) .

Reflexión final

ZF ha sido creado para hacer nuestro trabajo más simple. Pone a nuestra disposición adaptadores de diferentes motores de base de datos, de tal manera que para cambiar de, por ejemplo, MySQL a PostgreSQL bastaría con modificar solo unas cuantas líneas en su archivo de configuración.

Además las librerías que nos brinda son muy útiles. Hacer una validación de usuarios con ZF es muy simple y sobre todo segura usando Zend_Auth o subir un archivo usando Zend_File_Transfer_Adapter_Http es una tarea muy simple. En los siguientes artículos iremos viendo como realizar estas y otras tareas.

Esto ha sido solo una introducción a Zend Framework que espero les ayude en su trabajo como desarrolladores. Si tienen alguna consulta o algo no les quedó muy en claro, no duden en dejar su comentario.

¡Nos vemos en el próximo artículo!

¿Necesitas desarrollar un proyecto web o para móviles? ¡Estamos disponibles!

Visitar Cokidoo

Cokidoo, los creadores de Ontuts, desarrollamos proyectos tecnológicos centrados en redes sociales y aplicaciones web, aplicaciones móviles y consultoría web y bases de datos.

Somos jóvenes, inquietos, versátiles, apasionados por la innovación y enfocados en las nuevas tecnologías. Con Ontuts tratamos de compartir nuestro conocimiento adquirido en los distintos proyectos, ayudando a la comunidad y mostrando nuestra capacidad tecnológica.

Si necesitas un presupuesto sin compromiso, estamos disponibles, no dudes en contactar con nosotros.

Comentarios en esta publicación (13 comentarios)

¿Te ha gustado esta publicación? ¡Puedes compartir tu opinión con todos nosotros! Simplemente pincha aquí mismo.

Se agradece el tutorial.

Por mi parte soy usuario de CodeIgniter, con el que estoy muy conforme, pero varias veces he descargado Zend con intención de trastear un poco. Seguro que esta guía de iniciación me será de utilidad (¡¡el día que tenga tiempo de ponerme a ello!!!)

Yo la verdad nunca he trabajado con frameworks de PHP salvo para captar ideas para el Cokiframework que utilizamos en Cokidoo, pero espero impaciente el próximo capítulo :)

juan manuel

gracias, espero ahora si pueda entenderle al zend, he intentado usar php4aplications, cakephp, zend y otros pero no les entiendo NADA, espero ahora ya pueda entenderlo, mil gracias

daniel

Hola, yo estoy justamente en etapa de aprendizaje de Zend Framework, asi que estos artículos me vendrán como anillo al dedo.
Saludos y gracias.

Victor

Interesante tutorial corto me ayudo adespejar dudas y comparar con otros documentos largos y cansadores, espero que sigas continuando asi de forma especifica sacando tutoriales de zend framework saludos..

Gracias a todos por los comentarios. Creo que como dice Victor, hay muchos documentos/tutoriales cansados y ese creo que es el problema en ZF.
En el siguiente artículo, trataré de explicar un poco acerca de cómo manejar layouts. Si ven que es cansado, háganmelo saber porque la idea es hacer que programar usando ZF sea más ágil.

Bug

Error en el tutorial, el modulo de la estructura es “default y blog.” y no “default y news.”

Saludos

C-ChacK

Hola, tengo una aplicación hecha con Zend Framework corriendo perfectamente en mi localhost, he movido el contenido del directorio public al directorio raíz haciendo los cambios necesarios en el index.php, pero ahora me surge la duda de subirlo a un hosting. ¿Tengo que subir la carpeta library/Zend si no está instalado?

Martin

Hola he visto tu ejemplo de estructura modular con el archivo bootstrap en cada modulo y la duda que tengo es como indicar el directorio de las vistas que no sea agregándolo al include_path del bootstrap de la aplicacion para cada modulo. Estoy pensando que cada modulo probablemente necesite su propio archivo application.ini pero no estoy seguro que sea una buena opción.

Saludos

Luis Martin Grados Salinas

Hola muy buena la información, una ayuda a ver si me puedes dar.

Estoy desarrollando un proyecto en Zend FrameWork, y quiero subirlo a mi hosting.

Como haría para copiar la carpeta donde está el Zend FrameWork.

Gracias.

Pierre

en la estructura que colocaste donde va la carpeta layouts ?…

estoy haciendo mi tesis con zend y me va muy bien, lo unico que me hace falta la integracion con ajax y nose si algunos de ustedes me prodria ayudar ya que no encuentro una informacion sobre ajax y jquery con conexion a la base de datos.

Ivan

Interesante ZF, pero cuado cuesta?