Para crear su proyecto, primero debe descargar y extraer Zend Framework.
La forma más sencilla de obtener Zend Framework junto con una pila completa de PHP es instalando Zend Server. Zend Server dispone de instaladores nativos para Mac OSX, Windows, Fedora Core, y Ubuntu, así como un paquete de instalación universal compatible con la mayoría de las distribuciones de Linux.
Después de haber instalado Zend Server, los archivos del Framework se pueden encontrar
en /usr/local/zend/share/ZendFramework en Mac OSX y Linux,
y en C:\Program Files\Zend\ZendServer\share\ZendFramework en
Windows. El include_path ya estará configurado para incluir
Zend Framework.
Alternativamente, puede descargar la última versión de Zend Framework y extraer el contenido; tome nota de dónde lo ha hecho.
Opcionalmente, puede añadir la ruta al subdirectorio library/ de
el archivo a la configuración include_path de su
php.ini.
¡Eso es todo! Zend Framework ya está instalado y listo para usarse.
![[Note]](images/note.png) |
Herramienta de línea de comandos zf |
|---|---|
|
En su instalación de Zend Framework hay un subdirectorio Dondequiera que vea referencias al comando zf, sustituya la ruta absoluta al script. En sistemas tipo Unix, puede que desee utilizar la función de alias de su shell: alias zf.sh=path/to/ZendFramework/bin/zf.sh. Si tiene problemas configurando la herramienta de línea de comandos zf, consulte el manual. |
Abra una terminal (en Windows, Inicio -> Ejecutar, y luego use cmd). Navegue hasta un directorio donde desee iniciar un proyecto. Luego, use la ruta al script apropiado, y ejecute uno de los siguientes:
% zf create project quickstart
Al ejecutar este comando se creará la estructura básica de su sitio, incluyendo sus controladores y vistas iniciales. El árbol se ve como el siguiente:
quickstart
|-- application
| |-- Bootstrap.php
| |-- configs
| | `-- application.ini
| |-- controllers
| | |-- ErrorController.php
| | `-- IndexController.php
| |-- models
| `-- views
| |-- helpers
| `-- scripts
| |-- error
| | `-- error.phtml
| `-- index
| `-- index.phtml
|-- library
|-- public
| |-- .htaccess
| `-- index.php
`-- tests
|-- application
| `-- bootstrap.php
|-- library
| `-- bootstrap.php
`-- phpunit.xml
En este punto, si no ha añadido Zend Framework a su
include_path, recomendamos copiarlo o crear un enlace simbólico a él en
su directorio library/. En cualquier caso, querrá copiar
recursivamente o crear un enlace simbólico al directorio library/Zend/ de su
instalación de Zend Framework dentro del directorio library/ de su
proyecto. En sistemas tipo unix, eso se vería como uno de los siguientes:
# Symlink: % cd library; ln -s path/to/ZendFramework/library/Zend . # Copy: % cd library; cp -r path/to/ZendFramework/library/Zend .
En sistemas Windows, puede que sea más fácil hacer esto desde el Explorador.
Ahora que el proyecto está creado, los principales artefactos que hay que empezar a entender son el arranque (bootstrap), la configuración, los controladores de acciones y las vistas.
Su clase Bootstrap define qué recursos y componentes se
inicializan. Por defecto, se inicializa el Controlador
Frontal de Zend Framework, y utiliza
application/controllers/ como el directorio por defecto en el que buscar
los controladores de acciones (más sobre esto luego). La clase se ve como sigue:
// application/Bootstrap.php
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}
Como puede ver, no es necesario mucho para empezar.
Aunque Zend Framework en sí no requiere configuración, a menudo necesitará configurar su
aplicación. La configuración por defecto se coloca en
application/configs/application.ini, y contiene algunas directivas
básicas para configurar su entorno PHP (por ejemplo, activar y desactivar
el reporte de errores), indicando la ruta a su clase bootstrap (así como su
nombre de clase), y la ruta a sus controladores de acciones. Se ve de la siguiente manera:
; application/configs/application.ini [production] phpSettings.display_startup_errors = 0 phpSettings.display_errors = 0 includePaths.library = APPLICATION_PATH "/../library" bootstrap.path = APPLICATION_PATH "/Bootstrap.php" bootstrap.class = "Bootstrap" appnamespace = "Application" resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers" resources.frontController.params.displayExceptions = 0 [staging : production] [testing : production] phpSettings.display_startup_errors = 1 phpSettings.display_errors = 1 [development : production] phpSettings.display_startup_errors = 1 phpSettings.display_errors = 1
Se deben tener en cuenta varias cosas sobre este archivo. Primero, cuando se usa
configuración de estilo INI, puede referenciar constantes directamente y
expandirlas; APPLICATION_PATH es en realidad una constante. Además,
observe que hay varias secciones definidas: production, staging, testing y
development. Las últimas tres heredan la configuración del entorno "production". Esta
es una forma útil de organizar la configuración para asegurar que la configuración apropiada
esté disponible en cada etapa del desarrollo de la aplicación.
Los controladores de acciones de su aplicación contienen el flujo de trabajo de su aplicación, y realizan el trabajo de mapear sus solicitudes a los modelos y vistas apropiados.
Un controlador de acciones debe tener uno o más métodos que terminen en "Action"; estos métodos
pueden entonces solicitarse a través de la web. Por defecto, las URL de Zend Framework siguen el esquema
/controller/action, donde "controller" se corresponde con el nombre del
controlador de acciones (menos el sufijo "Controller") y "action" se corresponde con un método de acción
(menos el sufijo "Action").
Normalmente, siempre necesitará un IndexController, que es un
controlador de reserva y que también sirve la página de inicio del sitio, y un
ErrorController, que se utiliza para indicar cosas tales como
errores HTTP 404 (controlador o acción no encontrados) y
errores HTTP 500 (errores de la aplicación).
El IndexController por defecto es como sigue:
// application/controllers/IndexController.php
class IndexController extends Zend_Controller_Action
{
public function init()
{
/* Initialize action controller here */
}
public function indexAction()
{
// action body
}
}
Y el ErrorController por defecto es como sigue:
// application/controllers/ErrorController.php
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:
// 404 error -- controller or action not found
$this->getResponse()->setHttpResponseCode(404);
$this->view->message = 'Page not found';
break;
default:
// application error
$this->getResponse()->setHttpResponseCode(500);
$this->view->message = 'Application error';
break;
}
$this->view->exception = $errors->exception;
$this->view->request = $errors->request;
}
}
Notará que (1) el IndexController no contiene código real,
y (2) el ErrorController hace referencia a una propiedad "view".
Eso nos lleva perfectamente al siguiente tema.
Las vistas en Zend Framework están escritas en PHP plano. Los scripts de vista
se colocan en application/views/scripts/, donde se categorizan además
utilizando los nombres de los controladores. En nuestro caso, tenemos un
IndexController y un ErrorController,
y por lo tanto tenemos los subdirectorios correspondientes index/ y
error/ dentro de nuestro directorio de scripts de vista. Dentro de
estos subdirectorios, encontrará y creará scripts de vista que correspondan a cada
acción de controlador expuesta; en el caso por defecto, tenemos así los scripts de vista
index/index.phtml y error/error.phtml.
Los scripts de vista pueden contener cualquier marcado que desee, y usan la etiqueta de apertura <?php y la etiqueta de cierre ?> para insertar directivas de PHP.
Lo siguiente es lo que instalamos por defecto para el
script de vista index/index.phtml:
<!-- application/views/scripts/index/index.phtml -->
<style>
a:link,
a:visited
{
color: #0398CA;
}
span#zf-name
{
color: #91BE3F;
}
div#welcome
{
color: #FFFFFF;
background-image: url(http://framework.zend.com/images/bkg_header.jpg);
width: 600px;
height: 400px;
border: 2px solid #444444;
overflow: hidden;
text-align: center;
}
div#more-information
{
background-image: url(http://framework.zend.com/images/bkg_body-bottom.gif);
height: 100%;
}
</style>
<div id="welcome">
<h1>Welcome to the <span id="zf-name">Zend Framework!</span><h1 />
<h3>This is your project's main page<h3 />
<div id="more-information">
<p>
<img src="http://framework.zend.com/images/PoweredBy_ZF_4LightBG.png" />
</p>
<p>
Helpful Links: <br />
<a href="http://framework.zend.com/">Zend Framework Website</a> |
<a href="http://framework.zend.com/manual/en/">Zend Framework
Manual</a>
</p>
</div>
</div>
El script de vista error/error.phtml es un poco más interesante ya
que utiliza algunos condicionales de PHP:
<!-- application/views/scripts/error/error.phtml -->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN";
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Zend Framework Default Application</title>
</head>
<body>
<h1>An error occurred</h1>
<h2><?php echo $this->message ?></h2>
<?php if ('development' == $this->env): ?>
<h3>Exception information:</h3>
<p>
<b>Message:</b> <?php echo $this->exception->getMessage() ?>
</p>
<h3>Stack trace:</h3>
<pre><?php echo $this->exception->getTraceAsString() ?>
</pre>
<h3>Request Parameters:</h3>
<pre><?php echo var_export($this->request->getParams(), 1) ?>
</pre>
<?php endif ?>
</body>
</html>
Para efectos de este inicio rápido, asumiremos que está utilizando el servidor web Apache. Zend Framework funciona perfectamente bien con otros servidores web -- incluyendo Microsoft Internet Information Server, lighttpd, nginx, y más -- pero la mayoría de los desarrolladores deberían estar familiarizados con Apache como mínimo, y proporciona una introducción sencilla a la estructura de directorios y a las capacidades de reescritura de Zend Framework.
Para crear su vhost, necesita conocer la ubicación de su archivo
httpd.conf, y potencialmente dónde se ubican otros archivos de configuración.
Algunas ubicaciones comunes:
/etc/httpd/httpd.conf(Fedora, RHEL, y otros)/etc/apache2/httpd.conf(Debian, Ubuntu, y otros)/usr/local/zend/etc/httpd.conf(Zend Server en máquinas *nix)C:\Program Files\Zend\Apache2\conf(Zend Server en máquinas Windows)
Dentro de su httpd.conf (o httpd-vhosts.conf
en algunos sistemas), necesitará hacer dos cosas. Primero, asegúrese de que
NameVirtualHost esté definido; normalmente, lo establecerá a un valor de
"*:80". Segundo, defina un host virtual:
<VirtualHost *:80>
ServerName quickstart.local
DocumentRoot /path/to/quickstart/public
SetEnv APPLICATION_ENV "development"
<Directory /path/to/quickstart/public>
DirectoryIndex index.php
AllowOverride All
Order allow,deny
Allow from all
</Directory>
</VirtualHost>
Hay varias cosas a tener en cuenta. Primero, observe que la configuración DocumentRoot
especifica el subdirectorio public de nuestro proyecto; esto
significa que solo los archivos bajo ese directorio pueden ser servidos directamente por el servidor.
Segundo, observe las directivas AllowOverride, Order, y
Allow; estas son para permitirnos usar archivos
htacess dentro de nuestro proyecto. Durante el desarrollo, esto es una
buena práctica, ya que evita la necesidad de reiniciar constantemente el servidor web a medida que hace
cambios a las directivas de su sitio; sin embargo, en producción, probablemente debería llevar el
contenido de su archivo htaccess a la configuración de su servidor y
desactivar esto. Tercero, observe la directiva SetEnv. Lo que estamos haciendo
aquí es establecer una variable de entorno para su host virtual; esta variable será
recogida en index.php y utilizada para establecer la constante
APPLICATION_ENV para nuestra aplicación Zend Framework. En
producción, puede omitir esta directiva (en cuyo caso tomará por defecto el valor
"production") o establecerla explícitamente en "production".
Finalmente, necesitará añadir una entrada en su archivo hosts
correspondiente al valor que coloque en su directiva ServerName. En
sistemas tipo *nix, esto suele ser /etc/hosts; en Windows, normalmente lo
encontrará en C:\WINDOWS\system32\drivers\etc. Independientemente de
el sistema, la entrada se verá como sigue:
127.0.0.1 quickstart.local
Inicie su servidor web (o reinícielo), y debería estar listo para continuar.