Zend Framework es un framework open source para PHP desarrollado por Zend, empresa encargada de la mayor parte de las mejoras hechas a PHP, por lo que se podría decir que es el framework “oficial”. Nos referiremos a Zend Framework por sus iniciales ZF en esta guía de publicación semanal.

Características principales

ZF implementa el patron MVC, es 100% orientado a objetos y sus componentes tienen un bajo acoplamiento por lo que los puedes usar en forma independiente.  Un punto importante es que nos brinda un estándar de codificación que deberíamos seguir en nuestros proyectos.

A su vez, cuenta con soporte para internalización y localización de aplicaciones (construir sitios multi idioma, convertir formatos de fechas, monedas, etc. según la región. Algo importantísimo para crear aplicaciones con un enfoque global y llegar de la mejor manera a la mayor cantidad de gente posible).

Facilita el setup de nuestro proyecto brindándonos herramientas para crear la estructura de directorios, clases, etc. por línea de comandos, integración con phpUnit por medio de Zend_Test para facilitar el testing de nuestra aplicación.

¿Todavía queres más? Posee adapters para gran cantidad de tipos de bases de datos diferentes; brinda componentes para la autenticación y autorización de usuarios, envío de mails, cache en varios formatos,  creación de web services, etc.  Es simple, si tenes algo que hacer, seguramente ya lo tuvo que hacer alguien antes! Así que aprovecha eso para invertir menos tiempo en el desarrollo y hacer uso de componentes ya testeados.

Instalación

Lo primero es descargar la ultima versión desde el sitio oficial. Una vez descargado creamos la estructura de directorios. Puedes crearla automáticamente con Zend_Tool_Framework, o puedes hacerlo manualmente. La estructura inicial será así:

Como vemos tenemos unos cuantos archivos básicos por crear, ya lo iremos viendo y verán que simple que es.

Action Controllers

Los controladores son clases que extienden de Zend_Controller_Action. Cada controlador tiene unos métodos especiales cuya nombre tiene el sufijo “Action”, llamados “action methods”. Por default, las URLs en ZF son del tipo /controlador/action, es decir que si en nuestro IndexController tenemos un “pruebaAction” lo podremos ejecutar desde /index/prueba.

www.maestrosdelweb.com/index/prueba (si estuviéramos trabajándolo en este sitio)

El IndexController es el controlador por default.

class IndexController extends Zend_Controller_Action
{

    public function init()
    {

    }

    public function indexAction()
    {
       $this->view->mensaje = 'Primera aplicación con Zend Framework!';
    }

}

Su estructura es muy simple, en el método init() podremos poner tareas de inicialización y creamos un action llamado index, nada más.

Al ejecutarlo, ZF automáticamente relaciona el nombre del action con una vista que será renderizada. Esta vista tiene la extensión phml, así que en el caso del indexAction la vista asociada sera index.phtml dentro de la carpeta correspondiente al controlador index en views/scripts.

Para verlo bien claro:

/views/scripts/{controlador}/{action}.phtml

En el indexAction asignamos un texto a una variable de la vista, y en el archivo index.phtml lo mostramos haciendo echo $this->mensaje; en artículos posteriores hablaremos mas en detalle sobre controladores, vistas y demas.

ErrorController

Otro controlador particular es el ErrorController. Cada vez que se quiera ejecutar una página que no existe (error 404) o se produzca algún error en la aplicación (error 500) será ejecutado este controlador.

class ErrorController extends Zend_Controller_Action
{

    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:

                $this->getResponse()->setHttpResponseCode(404);
                $this->view->message = 'Pagina no encontrada';
                break;
            default:
                $this->getResponse()->setHttpResponseCode(500);
                $this->view->message = 'Ocurrio un error inesperado';
                break;
        }

    }
}

Configurando el htacces y el index.php

En htaccess lo que hacemos es, aplicando el patrón Front Controller, redirigir todas las peticiones al index.php y luego allí decidir que página mostrar.

RewriteEngine On
RewriteRule !\.(js|ico|txt|gif|jpg|png|css|pdf)$ index.php

Así que el siguiente paso será crear nuestro index:

// Definimos la ruta de /application
defined('APPLICATION_PATH')
 || define('APPLICATION_PATH',
 realpath(dirname(__FILE__) . '/../application'));

// El entorno de trabajo actual
defined('APPLICATION_ENV')
 || define('APPLICATION_ENV',
 (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
 : 'production'));

// Configuramos el include path, es decir los directorios donde estarán nuestros archivos
$rootPath = dirname(__FILE__)."/..";

set_include_path($rootPath . '/application/config' . PATH_SEPARATOR . $rootPath . '/library/');

// Zend_Application
require_once 'Zend/Application.php';

// Creamos la aplicacion
$application = new Zend_Application(
 APPLICATION_ENV,
 APPLICATION_PATH . '/configs/application.ini'
);

$application->bootstrap()->run();

Aquí creamos dos constantes (APPLICATION_PATH y APPLICATION_ENV) que usaremos a lo largo de la ejecución, configuramos el include path, creamos nuestra instancia de Zend_Application y le damos run!

Bootstrap y application.ini

En el index estamos haciendo referencia a un archivo llamado application.ini que todavía no creamos y que es ni más ni menos que la configuración de nuestro sitio. Para empezar crearemos algo simple:

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0

; bootsrap
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"

; frontController
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

; layout
resources.layout.layoutPath = APPLICATION_PATH "/layouts"

; Database
resources.db.adapter = "pdo_mysql"
resources.db.params.host = "localhost"
resources.db.params.username = "user"
resources.db.params.password = "pass"
resources.db.params.dbname = "dbname"

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[testing : production]

Hecho esto, debemos crear el Bootstrap, registrando en el autoloader el namespace de nuestra aplicación para poder instanciar las clases que usemos sin necesidad de hacer antes un include de dicho archivo:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initAutoloader() {
        $autoloader = Zend_Loader_Autoloader::getInstance();
        $autoloader->registerNamespace('App_')->setFallbackAutoloader(true);

        $resourceAutoloader = new Zend_Loader_Autoloader_Resource(
          array(
            'basePath' => APPLICATION_PATH,
            'namespace' => 'App',
            'resourceTypes' => array(
              'form' => array('path' => 'forms/', 'namespace' => 'Form'),
              'model' => array('path' => 'models/', 'namespace' => 'Model')
            )
	   )
	);
	}

}

Seteando un layout

Por último creamos el layout de nuestro sitio. Dentro de la carpeta “layouts”, creamos el archivo layout.phtml:

>!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
>html>
  >head>
  >meta http-equiv="content-type" content="text/html; charset=utf-8">
  >title>Primera aplicacion en Zend Framework>/title>
  >/head>
  >body>
    >?php
    echo $this->layout()->content;
    ?>
  >/body>
>/html>

Todo debería funcionar correctamente, podemos probar entrando a sitio.com,  sitio.com/index, sitio.com/index/index, en todos ellos podemos ver el mensaje de bienvenida.

Creando una aplicación modular

Otra organización de directorios muy usada es la siguiente:

Aquí tenemos nuestro sitio dividido en módulos, cada cual con sus propios controladores y vistas. Para realizar este cambio por un lado debemos cambiar la línea:

resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

por

resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"

Y por otro lado, como ya dijimos ahora tenemos nuestro sitio organizado en módulos. El módulo por defecto se llama “default”, así que creamos el directorio modules con un subdirectorio correspondiente al modulo default y copiamos allí las carpetas views y controller. Listo! Ya podemos acceder otra vez, teniendo en cuenta que las urls ahora serán del tipo www.maestrosdelweb.com/modulo/controlador/action.

Podremos verlo en funcionamiento desde maestrosdelweb.com, maestrosdelweb.com/default, maestrosdelweb.com/default/index, maestrosdelweb.com/default/index/index.

En cuanto a los controladores, es importante aclarar un pequeño cambio, usando esta estructura de directorios llevan como prefijo el nombre del módulo al que pertenecen. Así, el controlador Usuarios del modulo Alta se llamara Alta_UsuariosController. Esto no cuenta para el modulo default, los controladores allí ubicados no llevan ningún prefijo especial.

En este punto podríamos decir que hemos terminado con la instalación. En los próximos artículos hablaremos un poco más en detalle sobre las cosas que aquí vimos casi superficialmente, y sobre muchas otras.

Continuando con la guía

Estamos preparando varios capítulos para profundizar en el Framework Zend que iremos publicando cada semana para finalmente ofrecer una descarga completa en PDF.

Ir al siguiente capítulo: Guía Zend: Modelos y Zend_Db