Zend Framework: Estado del Arte http://bolsadeideas.cl/zsamer Thu, 18 Feb 2010 15:31:59 +0000 http://wordpress.org/?v=2.5.1 en ¡Iniciamos curso Zend Framework Febrero 2010! http://bolsadeideas.cl/zsamer/2010/01/%c2%a1iniciamos-curso-zend-framework-febrero-2010/ http://bolsadeideas.cl/zsamer/2010/01/%c2%a1iniciamos-curso-zend-framework-febrero-2010/#comments Sun, 24 Jan 2010 19:28:16 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=76 Damos oficialmente el anuncio de apertura de inscripciones del curso Introducción a Zend Framework (5ta edición) que iniciará el 1ro de Febrero de 2010!

‘Cursos Abiertos’ <> ‘Cursos Intensivos’

Les comento que los ‘cursos abiertos’ se van armando de forma libre a medida que los alumnos se van registrando. Si sobre la fecha de inicio del curso no se llegó al cupo mínimo de 10 alumnos, se postergará una semana el inicio del curso. En caso de superar el máximo de 20 alumnos, se abrirá un único segundo grupo a la semana siguiente. El próximo período de cursos se abrirán recién a partir de Marzo 2010 (fecha a confirmar).

Todos los cursos tienen una duración promedio de 2 meses, pero existe la posibilidad de armar grupos INTENSIVOS y REDUCIDOS de 1 mes de duración (a un costo mayor).

¡Promoción!

Es de público conocimiento que hace 3 años que los precios de los cursos se han mantenido invariables, por lo que este año aumentarán los ‘cursos abiertos’ de USD 50 a USD 60. Pero, a modo de promoción, quienes se inscriban durante esta semana (plazo hasta el domingo 24/1), lo podrán hacer a precio congelado! (luego no se aceptarán reclamos ;-)).

¡No pierdas tú lugar! Accede a usuarios.surforce.com e ingresa a la sección COMPRAR.

Toda la información sobre los cursos en surforce.com


Saludos! ;-)

]]> http://bolsadeideas.cl/zsamer/2010/01/%c2%a1iniciamos-curso-zend-framework-febrero-2010/feed/ Doctrine 2: Enterprise Persistence Layer for PHP 5.3 http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-enterprise-persistence-layer-for-php-53/ http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-enterprise-persistence-layer-for-php-53/#comments Tue, 24 Nov 2009 15:02:43 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=75 Quería compartir con ustedes una presentación muy buena sobre Doctrine 2 y las grandes ventajas que tiene respecto a sus otras versiones como la 1.2, resumiendo:

  • Es mucho más rápido, 30% menos en uso de memoria
  • 100% desacoplado
  • Las clases de entidades no necesitan heredan de ninguna otra clase como en la 1.2 que obliga la herencia de Doctrine_Record, entidades mucho más desacopladas y reutilizables.
  • NO nos impone otros métodos, propiedades, y otras basura en nuestro modelo de objetos de dominio o clases de entidades (En java se les conocen como POJO, DTO o Entity), ídem lo anterior, mucho más limpias y reutilizables
  • Desarrollado completamente en PHP5.3, el futuro de PHP y desarrollo de aplicaciones empresariales
  • Uso de namespace
  • Toma lo mejor de los ORM de Java, está basado en Hibernate y EntityManager y JPA (Java Persistence API )
  • Mucho más elegante, con estándares y buenas prácticas OOP e implementación de patrones de diseños
  • y muchas otras

Les dejo la presentación de Jonathan Wage (miembro del equipo de desarrollo de Doctrine 2), muy recomendado, lo que si está en ingles ;-)

Doctrine 2: Enterprise Persistence Layer for PHP
View more documents from Jonathan Wage.
]]> http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-enterprise-persistence-layer-for-php-53/feed/ Doctrine 2 ORM en Zend Framewok: parte II http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-orm-en-zend-framewok-parte-ii/ http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-orm-en-zend-framewok-parte-ii/#comments Mon, 23 Nov 2009 20:12:54 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=74 Continuando con nuestro articulo anterior Doctrine 2 ORM en Zend Framewok: parte I, en esta oportunidad quiero compartir unos tips de como integrar ORM Doctrine 2 con Zend Framework, para ello va ser necesario haber leido también el articulo sobre Bootstrapping con Zend Application, que será nuestra base para la integración.

Lo primero que tenemos que hacer es descargar Doctrine 2 (actualmente 2.0.0-ALPHA3), descomprimir en la carpeta "library" del proyecto Zend y luego agregar en application.ini las siguientes lineas:

PLAIN TEXT
CODE:
  1. autoloaderNamespaces.doctrine = "Doctrine"
  2. autoloaderNamespaces.proxies = "Proxies"

Con esto agregamos las librerías de Doctrine 2 en el Include Path de PHP.

Lo segundo que tenemos que hacer es crear un método _init en la clase Boostrap, a éste método le llamaremos _initDoctrine, obviamente ;-)

PLAIN TEXT
PHP:
  1. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
  2. {
  3.     protected function _initDoctrine() {
  4.         $config = new Configuration();
  5.         $cache = new ApcCache();
  6.         $config->setMetadataCacheImpl($cache);
  7.         $config->setQueryCacheImpl($cache);
  8.  
  9.         $config->setProxyDir(APPLICATION_PATH . "/../library" . DIRECTORY_SEPARATOR.'Proxies');
  10.         $config->setProxyNamespace('Proxies');
  11.        
  12.         $connPDO = array();
  13.  
  14.         $this->bootstrap('db');
  15.         $connPDO['pdo'] = $this->getResource('db')->getConnection();
  16.  
  17.         $conn = DriverManager::getConnection($connPDO, $config);
  18.         $em = EntityManager::create($conn, $config);
  19.  
  20.         Zend_Registry::set('em', $em);
  21.         return $em;
  22.     }
  23. }

Podemos observar que hace uso de namespace incluido en la versión 5.3 de PHP, también observamos que se hace uso de la conexión a la base de datos de Zend Db ($this->bootstrap('db')), configurado en "application.ini", obtenemos el objeto PDO de conexión y se lo entregamos al DriverManager de Doctrine 2 ;-) todo muy elegante ¿no?, finalmente lo guardamos en el Zend_Registry.

Luego creamos las clase Entity, que representan un objeto de dominio del sistema:

Address:

PLAIN TEXT
PHP:
  1. <?php
  2. namespace doctrineorm\models\entity;
  3.  
  4. /**
  5. * @Entity
  6. * @Table(name="addresses")
  7. */
  8. class Address {
  9.  
  10.     /**
  11.      * @Id
  12.      * @Column(type="integer")
  13.      * @GeneratedValue(strategy="AUTO")
  14.      */
  15.     private $id;
  16.  
  17.     /** @Column(type="string", length=255) */
  18.     private $street;
  19.  
  20.     /** @OneToOne(targetEntity="User", mappedBy="address") */
  21.     private $user;
  22.  
  23.     public function getId() {
  24.         return $this->id;
  25.     }
  26.  
  27.     public function getStreet() {
  28.         return $this->street;
  29.     }
  30.  
  31.     public function setStreet($street) {
  32.         $this->street = $street;
  33.     }
  34.  
  35.     public function getUser() {
  36.         return $this->user;
  37.     }
  38.  
  39.     public function setUser(User $user) {
  40.         if ($this->user !== $user) {
  41.             $this->user = $user;
  42.             $user->setAddress($this);
  43.         }
  44.     }
  45. }

y
User:

PLAIN TEXT
PHP:
  1. <?php
  2.  
  3. namespace doctrineorm\models\entity;
  4.  
  5. /**
  6. * @Entity
  7. * @Table(name="users")
  8. */
  9. class User {
  10.    
  11.     /**
  12.      * @Id
  13.      * @Column(type="integer")
  14.      * @GeneratedValue(strategy="AUTO")
  15.      */
  16.     private $id;
  17.  
  18.     /** @Column(type="string", length=50) */
  19.     private $name;
  20.  
  21.     /**
  22.      * @OneToOne(targetEntity="Address")
  23.      * @JoinColumn(name="address_id", referencedColumnName="id")
  24.      */
  25.     private $address;
  26.  
  27.     public function getId() {
  28.         return $this->id;
  29.     }
  30.  
  31.     public function getName() {
  32.         return $this->name;
  33.     }
  34.  
  35.     public function setName($name) {
  36.         $this->name = $name;
  37.     }
  38.  
  39.     public function getAddress() {
  40.         return $this->address;
  41.     }
  42.  
  43.     public function setAddress(Address $address) {
  44.         if ($this->address !== $address) {
  45.             $this->address = $address;
  46.             $address->setUser($this);
  47.         }
  48.     }
  49. }

Sin entrar en mucho detalle, ya que no es objetivo del post abundar, vemos que las relaciones entre clases se configuran mediante anotaciones (docblock annotations), más información aquí....

Nuestra clase de Modelo DAO UserDao:

PLAIN TEXT
PHP:
  1. <?php
  2. /**
  3. * Description of UserDao
  4. *
  5. * @author Andrés Guzmán
  6. */
  7.  
  8. require_once "doctrineorm/models/entity/User.php";
  9. require_once "doctrineorm/models/entity/Address.php";
  10.  
  11. use doctrineorm\models\entity\User;
  12. use doctrineorm\models\entity\Address;
  13.  
  14. class Doctrineorm_Model_UserDao
  15. {
  16.     public function getEntityManager() {
  17.         if(Zend_Registry::isRegistered('em')) {
  18.             return Zend_Registry::get('em');
  19.         }
  20.         return null;
  21.     }
  22.    
  23.     public function findAll() {
  24.         return $this->getEntityManager()->createQuery('select u from doctrineorm\models\entity\User u')->getResult();
  25.     }
  26.  
  27.     public function save(User $user) {
  28.         $this->getEntityManager()->persist($user);
  29.         $this->getEntityManager()->flush();
  30.     }
  31.  
  32.     /* ... etc, otros métodos del DAO (Data Access Object) ...*/
  33. }

La clase controladora IndexController.php dentro del módulo doctrineorm:

PLAIN TEXT
PHP:
  1. class Doctrineorm_IndexController extends Zend_Controller_Action
  2. {
  3.     private $_model;
  4.  
  5.     public function init()
  6.     {
  7.         parent::init();
  8.         $this->_model = new Doctrineorm_Model_UserDao();
  9.     }
  10.  
  11.     public function indexAction()
  12.     {
  13.         $this->view->title = "Hello World! Doctrine 2 and Zend Framework!";
  14.         $this->view->users = $this->_model->findAll();
  15.     }
  16. }

Finalmente la vista index.phtml:

PLAIN TEXT
PHP:
  1. <h3><?php echo $this->title ?></h3>
  2.  
  3. <?php foreach ($this->users as $user): ?>
  4. <strong>Name:</strong> <?php echo $user->getName()?> &nbsp;-&nbsp;
  5. <strong>Address:</strong> <?php echo $user->getAddress()->getStreet()?>
  6. <br />
  7. <?php endforeach; ?>

Como ven, es bastante simple de integrar con Doctrine 2, bienvenidos al mundo de ORM con Doctrine 2 y Zend Framework!

Hasta la próxima! ;-)

]]> http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-orm-en-zend-framewok-parte-ii/feed/ Doctrine 2 ORM en Zend Framewok: parte I http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-orm-en-zend-framewok-parte-i/ http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-orm-en-zend-framewok-parte-i/#comments Mon, 23 Nov 2009 19:16:37 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=73 Como muchos sabemos Zend Framework ha estado desarrollando su propio ORM Zend Entity (definición de ORM), sin embargo el proyecto de ORM nativo de Zend ha quedado parado y descontinuado, el propio autor, Benjamin Eberlei (@beberlei (Twitter)), comenta las causas en el siguiente post.

Lamentable noticia, sin embargo ésta viene acompañada de una excelente noticia: a partir de ahora, Benjamin Eberlei dedicará todos sus esfuerzos a mejorar el ORM Doctrine 2 y su integración con el Zend Framework, sin duda alguna, Doctrine 2 es y lo será por lejos el mejor ORM de PHP desde su versión 5.3 (Doctrine 2 requiere PHP 5.3 o superior).

Las razones que dieron lugar a esta decisión son las siguientes:

  1. Le consume demasiado tiempo y ha llegado a una situación de bloqueo
  2. Zend_Entity sólo tiene un desarrollador y por eso no tiene ni la mitad de características de Doctrine 2
  3. La fecha prevista de finalización de Zend_Entity era de hasta seis meses, algo que no encaja muy bien con la planificación de las nuevas versiones de Zend Framework

Matthew Weier O’Phinney, máximo responsable de Zend Framework, está de acuerdo con la decisión y comenta al respecto:

"creemos que ayudar a mejorar un proyecto existente Doctrine y trabajar en su integración con Zend Framework será mejor para toda la comunidad de PHP".


Lo más destacable de Doctrine 2 es que se basa completamente en EntityManager (Java EE 5) y JPA (Java Persistence API) con Hibernate (El mejor ORM de JAVA EE), muy parecido. Una maravilla. Además de implementar las clases Entity como corresponde, éstas aceptan anotaciones (docblock annotations) en los métodos para definir las relaciones de clases y mapeos hacia las tablas de las Bases de Datos.

No por nada el mismísimo Fabien Potencier, el boss de Simphony, dice que: "... Doctrine 2 es lo mejor que le ha pasado al PHP en mucho tiempo" pero de momento sólo está disponible una versión alpha 3 y no recomiendan su uso en proyectos de producción. A pesar de ello, creo es hora de empezar a probarlo.

Pienso que es una ventaja para la comunidad de Zend Framework pues ahora ya tenemos clara la herramienta a utilizar: bienvenido Doctrine 2.0 !

Continuamos en: Doctrine 2 ORM en Zend Framewok: parte II

]]> http://bolsadeideas.cl/zsamer/2009/11/doctrine-2-orm-en-zend-framewok-parte-i/feed/ Cambio de fecha de inicio de cursos: lunes 12 de Octubre http://bolsadeideas.cl/zsamer/2009/10/cambio-de-fecha-de-inicio-de-cursos-lunes-12-de-octubre/ http://bolsadeideas.cl/zsamer/2009/10/cambio-de-fecha-de-inicio-de-cursos-lunes-12-de-octubre/#comments Tue, 06 Oct 2009 13:46:29 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=72 Fecha de comienzo de curso a distancia Lunes 12 de Octubre, Introducción a Zend Framework.

Si aún no estás registrado en SURFORCE, ingresa TUS DATOS REALES (incluyendo la foto) en http://registracion.surforce.com (los datos son privados y confidenciales, sin ellos, no voy a enviar datos de pago ni habilitar alumnos bajo seudónimos ni nombres fantasía).

Aún quedan pocos lugares en el curso para llegar al tope máximo de 20 alumnos, NO pierdas tu lugar.

]]> http://bolsadeideas.cl/zsamer/2009/10/cambio-de-fecha-de-inicio-de-cursos-lunes-12-de-octubre/feed/ Últimos cursos del año 2009 http://bolsadeideas.cl/zsamer/2009/09/ultimos-cursos-del-ano-2009/ http://bolsadeideas.cl/zsamer/2009/09/ultimos-cursos-del-ano-2009/#comments Thu, 24 Sep 2009 04:23:28 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=71 Plazo para inscribirse hasta el Viernes 2 de Octubre.

Fecha de comienzo de cursos a distancia Lunes 5 de Octubre, Zend Framework y PHP5 OOP.

Si aún no estás registrado en SURFORCE, ingresa TUS DATOS REALES (incluyendo la foto) en http://registracion.surforce.com (los datos son privados y confidenciales, sin ellos, no voy a enviar datos de pago ni habilitar alumnos bajo seudónimos ni nombres fantasía).

Los cursos se dictarán a través de Moodle (sistema de educación a distancia) en la dirección http://formacion.surforce.com

Aún quedan algunos lugares en los cursos para llegar al tope máximo de 20 alumnos, así que quién envíe el pago inmediatamente obtiene el lugar disponible que aún no se ha pago.

]]> http://bolsadeideas.cl/zsamer/2009/09/ultimos-cursos-del-ano-2009/feed/ Inicio de cursos Zend Framework 7/Septiembre http://bolsadeideas.cl/zsamer/2009/09/inicio-de-cursos-zend-framework-7septiembre/ http://bolsadeideas.cl/zsamer/2009/09/inicio-de-cursos-zend-framework-7septiembre/#comments Wed, 02 Sep 2009 22:41:45 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=70 Si aún no estás registrado en SURFORCE, ingresa TUS DATOS REALES (incluyendo la foto) en http://registracion.surforce.com (los datos son privados y confidenciales, sin ellos, no voy a enviar datos de pago ni habilitar alumnos bajo seudónimos ni nombres fantasía).

Los cursos se dictarán a través de Moodle (sistema de educación a distancia) en la dirección http://formacion.surforce.com

Aún quedan algunos lugares en los cursos para llegar al tope máximo de 20 alumnos, así que quién envíe el pago inmediatamente obtiene el lugar disponible que aún no se ha pago.

¡Última semana, si no te inscribiste aún, luego no hay más excusas! ;-)

]]> http://bolsadeideas.cl/zsamer/2009/09/inicio-de-cursos-zend-framework-7septiembre/feed/ Bootstrapping con Zend Application http://bolsadeideas.cl/zsamer/2009/08/bootstrapping-con-zend-application/ http://bolsadeideas.cl/zsamer/2009/08/bootstrapping-con-zend-application/#comments Sun, 30 Aug 2009 01:34:16 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=68 Zend_Tool es una poderosa herramienta de Zend Framework que nos permite crear la estructura base de un proyecto Zend con todos sus directorios y componentes, como así también aprovechar un diseño estándar de proyecto y una primer clase de arranque (bootstrap) diseñada por los propios creadores del framework, ubicación para los archivos de configuración, diferenciación de entornos de ejecución (producción, desarrollo, etc), y muchos detalles más.

Crear nuestro proyecto base

Haremos un ejemplo basado en un sistema operativo como GNU/Linux, aunque esto bien se puede hacer también desde Windows a través de un .bat.

Dentro de nuestro web root, en Linux utilizando xampp: /opt/lampp/htdocs/

PLAIN TEXT
CODE:
  1. $ mkdir /opt/lampp/htdocs/proyecto-zf
  2. $ cd /opt/lampp/htdocs/proyecto-zf
  3. $ zf create project .
  4. Creating project at /opt/lampp/htdocs/proyecto-zf

Luego nos creará una estructura inicial para nuestro proyecto:

PLAIN TEXT
CODE:
  1. nuevo-proyecto-zf
  2. |-- application
  3. |   |-- Bootstrap.php
  4. |   |-- configs
  5. |   |   `-- application.ini
  6. |   |-- controllers
  7. |   |   |-- ErrorController.php
  8. |   |   `-- IndexController.php
  9. |   |-- models
  10. |   `-- views
  11. |       |-- helpers
  12. |       `-- scripts
  13. |           |-- error
  14. |           |   `-- error.phtml
  15. |           `-- index
  16. |               `-- index.phtml
  17. |-- library
  18. |-- public
  19. |   `-- index.php
  20. `-- tests
  21.     |-- application
  22.     |   `-- bootstrap.php
  23.     |-- library
  24.     |   `-- bootstrap.php
  25.     `-- phpunit.xml

De la estructura generada podemos observar lo siguiente:
Primero que todo, tenemos al directorio public. Este no solo guarda nuestro index.php quien se encarga de arrancar nuestra aplicación, sino que además contiene archivo de imágenes, hojas de estilos css, javascript etc.

Luego tenemos el directorio library, lugar donde guardamos nuestros propios componentes o librerías y las de Zend.

Después vemos que tenemos la carpeta tests, lugar donde llevaremos a cabo nuestras “pruebas unitarias” (testing). Esto puede ser usado generalmente para probar los modelos que deben contener la lógica de negocio y nuestros controladores.

Por último pero no menos importante es el directorio de la aplicación “application”. Este es considerado como el más importante, ya que es donde creamos y guardamos nuestra aplicación MVC, los controladores, modelo, vistas (script o plantillas y view helper) y archivos de configuración.
Se generó un directorio para nuestros archivos de configuración llamado configs, donde a su vez podemos ver un archivo application.ini que cuenta con los primeros parámetros que podemos definir en nuestra aplicación (entorno de producción, desarrollo, testing, si iniciar con el despliegue de mensajes de error, etc).

Nuestro archivo index.php ubicado dentro del directorio “public” quedaría más o menos con el siguiente contenido:

PLAIN TEXT
PHP:
  1. // Define path to application directory
  2. defined('APPLICATION_PATH')
  3.     || define('APPLICATION_PATH',
  4.               realpath(dirname(__FILE__) . '/../application'));
  5.  
  6. // Define application environment
  7. defined('APPLICATION_ENV')
  8.     || define('APPLICATION_ENV',
  9.               (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
  10.                                          : 'production'));
  11.  
  12. // Typically, you will also want to add your library/ directory
  13. // to the include_path, particularly if it contains your ZF installed
  14. set_include_path(implode(PATH_SEPARATOR, array(
  15.     dirname(dirname(__FILE__)) . '/library',
  17. )));
  18.  
  19. /** Zend_Application */
  20. require_once 'Zend/Application.php';
  21.  
  22. // Create application, bootstrap, and run
  23. $application = new Zend_Application(
  24.     APPLICATION_ENV,
  25.     APPLICATION_PATH . '/configs/application.ini'
  26. );
  27. $application->bootstrap()
  28.             ->run();

Podemos notar que la constante de ambiente de la aplicación "APPLICATION_ENV" referida al entorno o ambiente en que estemos, tales como de desarrollo, producción o test, esta se puede obtener directamente de la configuración del servidor web Apache, una recomendación puede ser configurarla directamente en el archivo htaccess, dentro del directorio “public”:

PLAIN TEXT
CODE:
  1. SetEnv APPLICATION_ENV development
  2.  
  3. RewriteEngine On
  4. RewriteCond %{REQUEST_FILENAME} -s [OR]
  5. RewriteCond %{REQUEST_FILENAME} -l [OR]
  6. RewriteCond %{REQUEST_FILENAME} -d
  7. RewriteRule ^.*$ - [NC,L]
  8. RewriteRule ^.*$ index.php [NC,L]

Adentrándonos en la Estructura de Directorio

Configs

Dentro del directorio configs, encontraremos un archivo llamado “application.ini”. Este archivo se utiliza para definir la configuración base del arranque de nuestro proyecto, el Boostrap. Veremos más adelante cómo podemos agregar recursos a la configuración del arranque, que son auto cargados por la aplicación cuando inicia. Lo fundamental es familiarizarnos con el archivo de configuración y se convertirá en uno de nuestros mejores aliados en ZF.
La configuración por defecto se coloca en “application/configs/application.ini”, y contiene algunas directrices básicas:

PLAIN TEXT
CODE:
  1. ; application/configs/application.ini
  2.  
  3. [production]
  4. phpSettings.display_startup_errors = 0
  5. phpSettings.display_errors = 0
  6. includePaths.library = APPLICATION_PATH "/../library"
  7. bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
  8. bootstrap.class = "Bootstrap"
  9. resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
  10.  
  11. [staging : production]
  12.  
  13. [testing : production]
  14. phpSettings.display_startup_errors = 1
  15. phpSettings.display_errors = 1
  16.  
  17. [development : production]
  18. phpSettings.display_startup_errors = 1
  19. phpSettings.display_errors = 1

Controladores

Dentro del directorio del controlador, se encuentran los archivos para cada controlador. Esto es algo que hemos visto muchas veces, así que no vamos a entrar en detalles. Al llegar a los módulos, no se olvide de anteponer el nombre de módulo, el prefijo, al nombre de clase (es decir, Admin_IndexController).

Modelos

Dentro del directorio de modelos, creamos nuestras clases modelos, un modelo contiene la lógica de negocio, pero no está vinculada a un motor de almacenamiento. Esto significa básicamente que los modelos no son sólo aquellos que extiendan de la clase Zend_Db_Table, sino que también otras fuentes de datos como un archivo plano (CVS), un XML, Web Service, SOAP, alguna fuente de dato proveniente de algún ERP etc.

Vistas

El directorio de las vistas, básicamente nuestras plantillas de presentación XHTML y las clase Helper View.

Añadiendo nuestras librerías

Por ejemplo, supongamos que hemos escrito un par de componentes para procesar archivos planos CVS y otras librerías más (como procesamiento de imágenes con GD) y las llamamos Core (nuestro propio core), entonces las almacenamos dentro del directorio library y en el sub directorio Core. Digamos que queremos añadir estas, sólo tenemos que añadir la siguiente entrada en el application.ini:

PLAIN TEXT
CODE:
  1. autoloaderNamespaces.core = "Core_"
  2. autoloaderNamespaces.otra  = "OtraLibreria_"
  3. autoloaderNamespaces.yotramas  = "YOtraLibreriaMas_"

Importante: desde nuestra aplicación, se espera que autoloaderNamespaces sea una matriz, razón por la cual necesitamos agregar una clave. Esto significa que podemos agregar múltiples bibliotecas personalizadas. Otro detalle a tener en cuenta es que hay que añadir un guión al final de su prefijo de la biblioteca. Tomando como ejemplo OtraLibreria, este hecho abre la puerta para las clases como OtraLibreria_NombreDeClase).

Agregando módulos

Perfecto, bueno y ¿Esto es todo? No, En realidad no… Como habrán notado, aun no tenemos un directorio de módulos. Así que vamos a cambiar eso y añadiremos nuestro primer módulo, llamado "admin".

PLAIN TEXT
CODE:
  1. $zf create module admin
  2. Creating the following module and artifacts:
  3. …………………..

Como pueden ver, crea un nuevo directorio llamado "modules" dentro del directorio “application”. Ahí se crea el directorio para el módulo "admin" con una estructura similar para el módulo como hemos descrito anteriormente.

Ahora vamos a crear un nuevo controlador para el módulo de modo que tengamos algo que mostrar en admin, quizás un saludo de bienvenida, esto lo hacemos manualmente como siempre lo hacemos.
Ahora, si intentamos en el navegador, ejecutar el módulo admin, vamos a obtener un mensaje de error "Message: Invalid controller specified (admin)".

Entonces, ¿qué hicimos mal? Nada en realidad. Ya que nuestra aplicación aun no está lista. Ya que hemos creado nuestro primer módulo, ahora tenemos que decirle a la configuración “application.ini” que nuestro sistema debe tener la estructura modular de directorio, por lo tanto, vamos a abrir application.ini y agregaremos las siguientes líneas al final del bloque de producción:

PLAIN TEXT
CODE:
  1. resources.frontController.moduleDirectory = APPLICATION_PATH "/ modules"
  2. resources.modules[] resources.modules []

Ahora estamos en condiciones de ejecutar nuestro módulo en el navegador:
http://localhost/proyecto-zf/public/admin/

El Bootstrap

La clase Bootstrap define que recursos y componentes que se deben inicializar. De forma predeterminada, el Front Controller es inicializado (Zend_Controller_Front), y configura por defecto el directorio “application/controllers/” para manejar los Controladores (Action Controllers).

PLAIN TEXT
PHP:
  1. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
  2. {
  3. }

En la clase Boostraps podemos incluir recursos para que estos sean inicializados cuando arranca la aplicación. Para ello debemos agregar métodos cuyo nombre debe comenzar con el carácter underscore [ _ ] seguido de la palabra init (llamado el prefijo _init) y el nombre del recurso, comenzando este último en mayúscula y caracteres alfanuméricos.

Ejemplo: _initNombreDelRecurso():

Veamos un ejemplo de una estructura típica de una clase Boostrap con Zend_Application:

PLAIN TEXT
PHP:
  1. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
  2. {
  3.     protected function _initFoo()
  4.     {
  5.         // ...
  6.     }
  7.  
  8.     protected function _initBar()
  9.     {
  10.         // ...
  11.     }
  12.  
  13.     protected function _initBaz()
  14.     {
  15.         // ...
  16.     }
  17. }

Para arrancar sólo el método _initFoo (), hacemos lo siguiente:

PLAIN TEXT
PHP:
  1. $bootstrap->bootstrap('foo');

Para arrancar los métodos _initFoo () e _initBar (), hacemos lo siguiente:

PLAIN TEXT
PHP:
  1. $bootstrap->bootstrap(array('foo', 'bar'));

Para inicializar todos los métodos de los recursos en el arranque, llamaremos a bootstrap() sin argumentos:

PLAIN TEXT
PHP:
  1. $bootstrap->bootstrap();

Este último es el más común y es el que observaremos en nuestro archivo de arranque index.php ubicado dentro del directorio “public”.

Veamos un ejemplo más en concreto, ahora agregaremos un recurso para inicializar el objeto vista, el cual queremos poder asignarle el HTML DocType y un valor por defecto al título HTML del sitio.
Esto puede ser implementado editando nuestra clase Bootstrap para agregar el método _initView(), veamos cómo a continuación:
?

PLAIN TEXT
PHP:
  1. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
  2. {
  3.     protected function _initView()
  4.     {
  5.         // Inicializamos el objeto vista
  6.         $view = new Zend_View();
  7.         $view->doctype('XHTML1_STRICT');
  8.         $view->headTitle('My First Zend Framework Application');
  9.  
  10.         // Agregamos la vista al ViewRenderer
  11.         $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(
  12.             'ViewRenderer'
  13.         );
  14.         $viewRenderer->setView($view);
  15.  
  16.         // Retornamos siempre el objeto recurso, en este caso la vista
  17.         // De esta manera el recurso será almacenado dentro del contenedor del Bootstrap
  18.         return $view;
  19.     }
  20. }

Este método se ejecutará automáticamente cuando se arranque la aplicación, y asegurará que nuestro objeto vista sea inicializado de acuerdo a la necesidad de nuestra aplicación.
De esta manera podríamos tener un método _initXXXX para cada uno de nuestros recursos que queramos inicializar, como por ejemplo:

  • _initConfig();
  • _initLog();
  • _initEnvironment();
  • _initLocale();
  • _initMail();
  • _initConnection();
  • _initLayout();

Este tipo de recursos son los llamados personalizados dentro de la clase Bootstrap, por lo tanto somos nosotros quienes tenemos que implementarlo según lo que necesitemos que se inicialice en nuestra aplicación.
?
Luego, para obtener un recurso tenemos que hacerlo de las siguientes formas:

Dentro de la Clase Boostrap

PLAIN TEXT
PHP:
  1. $view = $this->getResource('view');

Dentro de Algún Controlador

PLAIN TEXT
PHP:
  1. $bootstrap = $this->getInvokeArg('bootstrap');
  2. $view = $bootstrap->getResource('view');

Para asegurarnos que el contenedor de Boostrap contiene al recursos, llamamos al método hasResource(string recurso):

PLAIN TEXT
PHP:
  1. if ($bootstrap->hasResource('view')) {
  2.     $view = $bootstrap->getResource('view');
  3. }

Ahora tenemos otras formas de agregar recursos y estos ya están implementados implícitamente dentro de Zend_Application (por defecto), es decir ya están disponibles y listos para usar, gracias a Zend Framework, estos son los llamados “Plugins de Recursos Disponibles”.

Para utilizarlos sólo tenemos que configurarlo (activarlo) dentro del archivo de configuración “application.ini” (lo que veremos a continuación).

Plugins de Recursos Disponibles

Resource Layout

Unos de los recursos estándar que nos provee Zend Application es el Recurso de Layout. Para activar este recurso sólo tenemos que configurar de manera adecuada nuestro archivo de configuración “application.ini” definiendo los valores para la instancia del objeto Zend Layout, nombre del layout por defecto y el path:

Entonces dentro de la etiqueta production agregamos lo siguiente:

PLAIN TEXT
CODE:
  1. ; Agregamos las siguientes lineas:
  2. resources.layout.layout = "layout"
  3. resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"

Luego tenemos que crear nuestro archivo de layout dentro de la ruta especificada en la configuración “application/layouts/scripts/” el cual llamaremos layout.phtml:

PLAIN TEXT
PHP:
  1. <?php echo $this->doctype() ?>
  2. <html>
  3. <head>
  4.     <?php echo $this->headTitle() ?>
  5.     <?php echo $this->headLink() ?>
  6.     <?php echo $this->headStyle() ?>
  7.     <?php echo $this->headScript() ?>
  8. </head>
  9. <body>
  10.     <?php echo $this->layout()->content ?>
  11. </body>
  12. </html>

Resource View

También Zend Application nos provee de un recurso para la vista, solo tenemos que agregar unas líneas en el archivo application.ini como se muestra a continuación:

PLAIN TEXT
CODE:
  1. resources.view.encoding = "UTF-8"
  2. resources.view.basePath = APPLICATION_PATH "/views/scripts"

Resource Db

Tampoco se podía quedar atrás la inicialización de la conexión a las base de datos.
Zend_Application_Resource_Db inicializará un adaptador Zend_Db basado en las configuraciones asignadas en application.ini. De forma predeterminada, éste también asigna el adaptador por defecto del adaptador que debe utilizar Zend_Db_Table:

PLAIN TEXT
CODE:
  1. [production]
  2. resources.db.adapter = "pdo_mysql"
  3. resources.db.params.host = "localhost"
  4. resources.db.params.username = "webuser"
  5. resources.db.params.password = "XXXXXXX"
  6. resources.db.params.dbname = "test"
  7. resources.db.isDefaultTableAdapter = true

Resource Frontcontroller

Probablemente el recurso más importante y común que se carga con Zend_Application será el recurso Front Controller, que nos proporciona la capacidad de configurar Zend_Controller_Front.
Este recurso proporciona la capacidad de establecer parámetros del front controller, especificar los plugins a inicializar, y mucho más.

Una vez inicializado, el recurso asigna la propiedad $frontController del arranque a la instancia Zend_Controller_Front.

PLAIN TEXT
CODE:
  1. [production]
  2. resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
  3. resources.frontController.moduleControllerDirectoryName = "actions"
  4. resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"
  5. resources.frontController.defaultControllerName = "site"
  6. resources.frontController.defaultAction = "home"
  7. resources.frontController.defaultModule = "static"
  8. resources.frontController.baseUrl = "/subdir"
  9. resources.frontController.plugins.foo = "My_Plugin_Foo"
  10. resources.frontController.plugins.bar = "My_Plugin_Bar"
  11. resources.frontController.env = APPLICATION_ENV

Nos adentramos en el funcionamiento de Zend Application, las funcionalidades que puede involucrar, como así también algunas de las posibilidades para ampliarlo, creando un archivo de configuración o iniciando un sistema de logger con Zend_Log, etc.

]]> http://bolsadeideas.cl/zsamer/2009/08/bootstrapping-con-zend-application/feed/ PHP 5.3.0 Liberado! http://bolsadeideas.cl/zsamer/2009/06/php-530-liberado/ http://bolsadeideas.cl/zsamer/2009/06/php-530-liberado/#comments Tue, 30 Jun 2009 13:32:00 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=67 Lo prometido es cumplido, tal como anunciaron hace tres días, el equipo de PHP ha liberado la versión de PHP 5.3.0. Esta versión es una mejora importante en la serie 5.X, que incluye un gran número de nuevas características y corrección de errores.

Algunas de las nuevas características clave incluyen: namespaces, late static binding, closures, opcional garbage collection para eliminar objetos que no están siendo utilizados/referenciados, las nuevas extensiones (como ext / far, ext / intl y ext / FileInfo), más de 140 correcciones de errores y mucho más.

También tenemos una completa guía de emigración desde la versión PHP 5.2.

Más detalles sobre la liberación de PHP 5.3.0 se puede encontrar aquí.

Descargar PHP 5.3.0.

]]> http://bolsadeideas.cl/zsamer/2009/06/php-530-liberado/feed/ PHP 5.3 el próximo 30 de Junio http://bolsadeideas.cl/zsamer/2009/06/php-53-el-proximo-30-de-junio/ http://bolsadeideas.cl/zsamer/2009/06/php-53-el-proximo-30-de-junio/#comments Sat, 27 Jun 2009 17:03:23 +0000 zsamer http://bolsadeideas.cl/zsamer/?p=66 Una muy alentadora noticia de la larga espera de todos nosotros desarrolladores PHP5.

Finalmente la larga espera ya tiene un fin: los desarrolladores de PHP anunciaron en la lista de php.internals que postergaron el lanzamiento de la versión definitiva del anticipado PHP 5.3.0 hasta el Martes 30 de Junio, con sus Mirrors comenzando a actualizarse a partir de próximo Lunes.

Todavía se están agregando parches de último momento, como los que corrigen problemas con el driver nativo de MySQL, las funciones de fecha y la inicialización en sistemas Sparc. Todoas las demás correcciones de errores no-críticos se postergarán hasta la siguiente versión 5.3.1, todavía sin fecha de lanzamiento.

PHP 5.3.0 incluye importantísimas novedades, como por ejemplo: Namespaces (espacios de nombre), funciones anónimas (lambda y closures), driver nativo de MySQL, soporte mejorado para Windows, archivos Phar (similares a los JAR de Java) y hasta el polémico operador goto.

Fuente: VivaPHP

]]> http://bolsadeideas.cl/zsamer/2009/06/php-53-el-proximo-30-de-junio/feed/