Desarrollador Senior

DevDocs: Documentación para desarrolladores web en un mismo lugar

2012-05-06T23:57:00.001+02:00

Me gustó mucho DevDocs, ya que permite buscar de forma sencilla y clara en la documentación de las especificaciones de CSS, HTML, JavaScript, DOM, sumando también las de jQuery, PHP y Python. Toda la información es sacada de los sitios oficiales o confiables.

Muy recomendado para tener guardado entre los marcadores.

Libro gratuito de jQuery en español: Fundamentos de jQuery

2011-03-31T15:19:00.001+02:00

Después de un par de meses de trabajo, les quería contar sobre mi pequeño aporte a la comunidad de diseñadores y desarrolladores web: Fundamentos de jQuery, un libro-web totalmente en español para aprender jQuery desde cero.

El mismo abarca tanto conceptos básicos de JavaScript/jQuery (selectores, eventos, efectos, etc) como avanzados (creación de extensiones, patrones de organización del código, programación con eventos personalizados).

El material es una adaptación del trabajo original realizado por Rebecca Murphey, bajo licencia Creative Commons.

Contenidos del material

Asi que ya saben, si estan dando sus primeros pasos con jQuery, quieren aprender algunos nuevos conceptos o necesitan algún material de referencia en español, pueden darse una vuelta: http://librojquery.com/

Estilo arquitectónico capas

2010-05-04T21:50:00.003+02:00

La programación por capas es un estilo de programación en el que el objetivo primordial es la separación de la lógica de negocios de la lógica de diseño.[1]

Cuando trabajamos sobre aplicaciones web uno de los estilos arquitectónicos utilizado es el estilo Capas. En este estilo pueden utilizarse varias variantes, con 2 capas, 3 capas y hasta n capas, siendo el más común el de 3 capas.

La ventaja principal de este estilo arquitectónico es que en caso de que sobrevenga algún cambio, sólo se ataca al nivel requerido sin tener que revisar entre código mezclado.

La capa de presentación: es la encargada de interactuar con el usuario y se corresponde con lo que tradicionalmente se conoce como interfaz de usuario, esta capa se comunica únicamente con la capa de negocio. Un formlario,ejemplo de una capa de presentación:

Una buena regla general para determinar si la capa de presentación está suficientemente limpia de código es que debería contener una cantidad mínima de código PHP, la suficiente como para que un diseñador HTML sin conocimientos de PHP pueda entenderla. Las instrucciones más comunes en la parte de la vista suelen ser echo, if/else, foreach/endforeach y poco más. Además, no se deben incluir instrucciones PHP que generen etiquetas HTML.

En la capa de negocio o aplicación o intermedia: es donde se localiza la lógica del negocio. Esta capa recibe la petición del usuario a través de la capa de presentación y se encarga de darle curso, recurriendo normalmente a los repositorios de información, dicha capa es donde se implementan las reglas del negocio, las validaciones y cálculos.

La capa de acceso a datos: es la encargada de acceder a los repositorios de información, ejemplo de estas bases de datos.

Como se muestra en la figura la relación entre las capas es unidireccional, es decir solo las capas superiores pueden utilizar los servicios que brindan las capas inferiores, aunque los subsistemas que se encuentran en la misma capa si pueden interactuar entre si.

Otros artículos sobre Patrones

Referencias Bibliográficas

[1] Colaboradores de Wikipedia. Programación por capas [en línea]. Wikipedia, La enciclopedia libre, 2010 [fecha de consulta: 6 de marzo del 2010]. Disponible en <http://es.wikipedia.org/w/index.php?title=Programaci%C3%B3n_por_capas&oldid=34731234>.

Abstraerse de los servicios que proveen las herramientas de abstracción de acceso a Bases de Datos

2009-12-15T03:52:00.005+01:00

Como habíamos visto en nuestro post anterior

PDO (PHP Data Objects). Capa de Abstracción de acceso a Bases de Datos utilizando el Patrón de diseño Singleton (Segunda parte)

Nuestra clase Database que usa internamente el Patrón Singleton: crea una instancia de la clase PDO a través del método getInstance(), pudiendo así invocar todos los métodos y propiedades de la misma.

¿Pero que inconveniente tendríamos si quisiéramos cambiar la Capa de Abstracción de acceso a la Bases de Datos para utilizar ADODB en vez de PDO?

Supongamos que desarrollamos todo nuestro sistema invocando las propiedades y métodos que nos provee PDO.

Inconvenientes

Estaríamos atados a una implementación concreta, con lo que rompemos con una premisa del Diseño Orientado a Objetos.

“No dependas de implementaciones concretas, solo de implementaciones abstractas”

Tendríamos que re implementar toda nuestra lógica de negocio donde quiera que hayamos utilizado una propiedad o método pertenecientes a PDO.

Solución

Adaptar la clase Database para que se abstraiga de las propiedades y métodos concretos que proveen las herramientas de Abstracción de Acceso a Bases de Datos como PDO y ADODB.

Nuestra clase Database debe contener todas las operaciones necesarias para interactuar con cualquier base de datos, pero estos métodos no estarán programados desde cero (reutilización de código), sino que reutilizan internamente algún servicio (extensión o librería) de abstracción de BD. En este caso utilizaremos PDO.

Ejemplo

database.php

view plain copy to clipboard print ?

<?php
require_once 'web.config.php';
/**
* Represents a connection between PHP and a database server
*
*/
final class Database extends PDO
{
static private $dns = DNS;
static private $username = USERNAME;
static private $passwd = PASSWD;
static private $options;
static private $instance;
static private $constructIsPrivate = true;
/**
* A private constructor; prevents direct creation of object
*
* @access static private
*/
public function __construct()
{
if (self::$constructIsPrivate) {
trigger_error('Call to private ' . __CLASS__ .
'::__construct() from invalid context', E_USER_ERROR);
}
try {
parent::__construct(self::$dns, self::$username, self::$passwd);
$this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
echo 'Connection failed: ' . $e->getMessage();
}
}
/**
* Create a instance of Database class with The singleton method
*
* @access static public
* @return Database object
*/
static public function getInstance()
{
if (!isset(self::$instance))
{
self::$constructIsPrivate = false;
$c = __CLASS__;
self::$instance = new $c;
self::$constructIsPrivate = true;
}
return self::$instance;
}
/**
* Initiates a transaction
*
* @access public
* @return bool
*/
public function beginTransaction()
{
return parent::beginTransaction();
}
/**
* Commits a transaction
*
* @access public
* @return bool
*/
public function commit()
{
return parent::commit();
}
/**
* Fetch the SQLSTATE associated with the last operation on the database handle
*
* @access public
* @return string
*/
public function errorCode()
{
return parent::errorCode();
}
/**
* Fetch extended error information associated with the last operation on the database handle
*
* @access public
* @return array
*/
public function errorInfo()
{
return parent::errorInfo();
}
/**
* Execute an SQL statement and return the number of affected rows
*
* @access public
* @param string $statement
* @return int
*/
public function exec($statement)
{
return parent::exec($statement);
}
/**
* Return an array of available PDO drivers
*
* @access static public
* @return array
*/
static public function getAvailableDrivers()
{
return parent::getAvailableDrivers();
}
/**
* Returns the ID of the last inserted row or sequence value
*
* @access public
* @param string[optional] $name
* @return string
*/
public function lastInsertId($name = null)
{
return parent::lastInsertId($name);
}
/**
* Prepares a statement for execution and returns a statement object
*
* @access public
* @param string $statement
* @param array $driver_options
* @return PDOStatement
*/
public function prepare($statement, $driver_options = array() )
{
return parent::prepare($statement, $driver_options);
}
/**
* Executes an SQL statement, returning a result set as a PDOStatement object
*
* @access public
* @param string $statement
* @return PDOStatement
*/
public function query()
{
$args = func_get_args();
switch(func_num_args()) {
case 1:
return parent::query($args[0]);
break;
case 2:
return parent::query($args[0], $args[1]);
break;
case 3:
return parent::query($args[0], $args[1], $args[2]);
break;
case 4:
return parent::query($args[0], $args[1], $args[2], $args[3]);
break;
}
}
/**
* Quotes a string for use in a query
*
* @access public
* @param string $string
* @param int[optional] $parameter_type
* @return string
*/
public function quote($string, $parameter_type = PDO::PARAM_STR )
{
return parent::quote($string, $parameter_type);
}
/**
* Rolls back a transaction
*
* @access public
* @return bool
*/
public function rollBack()
{
return parent::rollBack();
}
/**
* Set an attribute
*
* @access public
* @param int $attribute
* @param mixed $value
* @return bool
*/
public function setAttribute($attribute, $value)
{
return parent::setAttribute($attribute, $value);
}
/**
* Bind a column to a PHP variable
*
* @access public
* @param mixed $column
* @param mixed $param
* @param int[optional] $type
* @param int[optional] $maxlen
* @param mixed[optional] $driverdata
* @return bool
*/
public function bindColumn($column, &$param, $type = null, $maxlen = null, $driverdata = null)
{
return parent::bindColumn($column, &$param, $type, $maxlen, $driverdata);
}
/**
* Binds a parameter to the specified variable name
*
* @access public
* @param mixed $parameter
* @param mixed $variable
* @param int[optional] $data_type
* @param int[optional] $length
* @param mixed[optional] $driver_options
* @return bool
*/
public function bindParam($parameter, &$variable, $data_type = PDO::PARAM_STR, $length = null, $driver_options = null)
{
return parent::bindParam($parameter, &$variable, $data_type, $length, $driver_options);
}
/**
* Binds a value to a parameter
*
* @access public
* @param mixed $parameter
* @param mixed $value
* @param int[optional] $data_type
* @return bool
*/
public function bindValue($parameter, $value, $data_type = PDO::PARAM_STR)
{
return parent::bindValue($parameter, $value, $data_type);
}
/**
* Closes the cursor, enabling the statement to be executed again
*
* @access public
* @return bool
*/
public function closeCursor()
{
return parent::closeCursor();
}
/**
* Returns the number of columns in the result set
*
* @access public
* @return int
*/
public function columnCount()
{
return parent::columnCount();
}
/**
* Dump a SQL prepared command
*
* @access public
*/
public function debugDumpParams()
{
return parent::debugDumpParams();
}
/**
* Executes a prepared statement
*
* @access public
* @param array $input_parameters
* @return bool
*/
public function execute($input_parameters = array())
{
return parent::execute($input_parameters);
}
/**
* Fetches the next row from a result set
*
* @access public
* @param int[optional] $fetch_style
* @param int[optional] $cursor_orientation
* @param int[optional] $cursor_offset
* @return mixed
*/
public function fetch($fetch_style = PDO::FETCH_BOTH, $cursor_orientation = PDO::FETCH_ORI_NEXT, $cursor_offset = 0)
{
return parent::fetch($fetch_style, $cursor_orientation, $cursor_offset);
}
/**
* Returns an array containing all of the result set rows
*
* @access public
* @param int[optional] $fetch_style
* @param int[optional] $column_index
* @param array $ctor_args
* @return array
*/
public function fetchAll($fetch_style = PDO::FETCH_BOTH, $column_index = 0 , $ctor_args = array())
{
return parent::fetchAll($fetch_style, $column_index, $ctor_args);
}
/**
* Returns a single column from the next row of a result set
*
* @access public
* @param int[optional] $column_number
* @return string
*/
public function fetchColumn($column_number = 0)
{
return parent::fetchColumn($column_number);
}
/**
* Fetches the next row and returns it as an object
*
* @access public
* @param string[optional] $class_name
* @param array $ctor_args
* @return mixed
*/
public function fetchObject($class_name = 'stdClass', $ctor_args = null)
{
return parent::fetchObject($class_name, $ctor_args);
}
/**
* Retrieve a attribute
*
* @access public
* @param int $attribute
* @return mixed
*/
public function getAttribute($attribute)
{
return parent::getAttribute($attribute);
}
/**
* Returns metadata for a column in a result set
*
* @access public
* @param int $column
* @return array
*/
public function getColumnMeta($column)
{
return parent::getColumnMeta($column);
}
/**
* Advances to the next rowset in a multi-rowset statement handle
*
* @access public
* @return bool
*/
public function nextRowset()
{
return parent::nextRowset();
}
/**
* Returns the number of rows affected by the last SQL statement
*
* @access public
* @return int the number of rows.
*/
public function rowCount()
{
return parent::rowCount();
}
/**
* Set the default fetch mode for this statement
*
* @access public
* @param $PDO
* @param object $object
* @return bool
*/
public function setFetchMode()
{
$args = func_get_args();
switch(func_num_args()) {
case 1:
return parent::setFetchMode($args[0]);
break;
case 2:
return parent::setFetchMode($args[0], $args[1]);
break;
case 3:
return parent::setFetchMode($args[0], $args[1], $args[2]);
break;
}
}
/**
* Prevent users to clone the instance
*
* @access public
* @return string trigger_error
*/
public function __clone()
{
trigger_error('Clone is not allowed.', E_USER_ERROR);
}
}
?>

<?php<br /> require_once 'web.config.php';<br /> <br /> /**<br /> * Represents a connection between PHP and a database server<br /> *<br /> */<br /> final class Database extends PDO<br /> {<br /> static private  $dns = DNS;<br /> static private  $username = USERNAME;<br /> static private  $passwd = PASSWD;<br /> static private  $options;<br /> static private  $instance;<br /> static private  $constructIsPrivate = true;<br /> <br /> /**<br /> * A private constructor; prevents direct creation of object<br /> *<br /> * @access static private<br /> */<br /> public function __construct()<br /> {<br /> if (self::$constructIsPrivate) {<br /> trigger_error('Call to private ' . __CLASS__ . <br /> '::__construct() from invalid context', E_USER_ERROR);<br /> }<br /> try {<br /> parent::__construct(self::$dns, self::$username, self::$passwd);<br /> $this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);<br /> } catch (PDOException $e) {<br /> echo 'Connection failed: ' . $e->getMessage();<br /> }<br /> }<br /> <br /> /**<br /> * Create a instance of Database class with The singleton method<br /> *<br /> * @access static public<br /> * @return Database object<br /> */<br /> static public function getInstance()<br /> {<br /> if (!isset(self::$instance))<br /> {<br /> self::$constructIsPrivate = false;<br /> $c = __CLASS__;<br /> self::$instance = new $c;<br /> self::$constructIsPrivate = true;<br /> }<br /> return self::$instance;<br /> }<br /> <br /> /**<br /> * Initiates a transaction<br /> *<br /> * @access public<br /> * @return bool<br /> */<br /> public function beginTransaction()<br /> {<br /> return parent::beginTransaction();<br /> }<br /> <br /> /**<br /> * Commits a transaction <br /> *<br /> * @access public<br /> * @return bool<br /> */<br /> public function commit()<br /> {<br /> return parent::commit();<br /> }<br /> <br /> /**<br /> * Fetch the SQLSTATE associated with the last operation on the database handle<br /> *<br /> * @access public<br /> * @return string<br /> */<br /> public function errorCode()<br /> {<br /> return parent::errorCode();<br /> }<br /> <br /> /**<br /> * Fetch extended error information associated with the last operation on the database handle<br /> *<br /> * @access public<br /> * @return array<br /> */<br /> public function errorInfo()<br /> {<br /> return parent::errorInfo();<br /> }<br /> <br /> /**<br /> * Execute an SQL statement and return the number of affected rows<br /> *<br /> * @access public<br /> * @param  string $statement<br /> * @return int<br /> */<br /> public function exec($statement)<br /> {<br /> return parent::exec($statement);<br /> }<br /> <br /> /**<br /> * Return an array of available PDO drivers<br /> *<br /> * @access static public<br /> * @return array<br /> */<br /> static public function getAvailableDrivers()<br /> {<br /> return parent::getAvailableDrivers();<br /> }<br /> <br /> /**<br /> * Returns the ID of the last inserted row or sequence value <br /> *<br /> * @access public<br /> * @param  string[optional] $name<br /> * @return string<br /> */<br /> public function lastInsertId($name = null)<br /> {<br /> return parent::lastInsertId($name);<br /> }<br /> <br /> /**<br /> * Prepares a statement for execution and returns a statement object<br /> *<br /> * @access public<br /> * @param  string $statement<br /> * @param  array  $driver_options<br /> * @return PDOStatement<br /> */<br /> public function prepare($statement, $driver_options = array() )<br /> {<br /> return parent::prepare($statement, $driver_options);<br /> }<br /> <br /> /**<br /> * Executes an SQL statement, returning a result set as a PDOStatement object<br /> *<br /> * @access public<br /> * @param  string $statement<br /> * @return PDOStatement<br /> */<br /> public function query()<br /> {<br /> $args = func_get_args();<br /> switch(func_num_args()) {<br /> case 1:<br /> return parent::query($args[0]);<br /> break;<br /> case 2:<br /> return parent::query($args[0], $args[1]);<br /> break;<br /> case 3:<br /> return parent::query($args[0], $args[1], $args[2]);<br /> break;<br /> case 4:<br /> return parent::query($args[0], $args[1], $args[2], $args[3]);<br /> break;<br /> }<br /> }<br /> <br /> /**<br /> * Quotes a string for use in a query<br /> *<br /> * @access public<br /> * @param  string        $string<br /> * @param  int[optional] $parameter_type<br /> * @return string<br /> */<br /> public function quote($string, $parameter_type = PDO::PARAM_STR )<br /> {<br /> return parent::quote($string, $parameter_type);<br /> }<br /> <br /> /**<br /> * Rolls back a transaction <br /> *<br /> * @access public<br /> * @return bool<br /> */<br /> public function rollBack()<br /> {<br /> return parent::rollBack();<br /> }<br /> <br /> /**<br /> * Set an attribute<br /> *<br /> * @access public<br /> * @param  int   $attribute<br /> * @param  mixed $value<br /> * @return bool<br /> */<br /> public function setAttribute($attribute, $value)<br /> {<br /> return parent::setAttribute($attribute, $value);<br /> }<br /> <br /> /**<br /> * Bind a column to a PHP variable <br /> *<br /> * @access public<br /> * @param  mixed           $column<br /> * @param  mixed           $param<br /> * @param  int[optional]   $type<br /> * @param  int[optional]   $maxlen<br /> * @param  mixed[optional] $driverdata<br /> * @return bool<br /> */<br /> public function bindColumn($column, &$param, $type = null, $maxlen = null, $driverdata = null)<br /> {<br /> return parent::bindColumn($column, &$param, $type, $maxlen, $driverdata);<br /> }<br /> <br /> /**<br /> * Binds a parameter to the specified variable name<br /> *<br /> * @access public<br /> * @param  mixed           $parameter <br /> * @param  mixed           $variable <br /> * @param  int[optional]   $data_type<br /> * @param  int[optional]   $length<br /> * @param  mixed[optional] $driver_options<br /> * @return bool<br /> */<br /> public function bindParam($parameter, &$variable, $data_type = PDO::PARAM_STR, $length = null, $driver_options = null)<br /> {<br /> return parent::bindParam($parameter, &$variable, $data_type, $length, $driver_options);<br /> }<br /> <br /> /**<br /> * Binds a value to a parameter<br /> *<br /> * @access public<br /> * @param  mixed         $parameter<br /> * @param  mixed         $value<br /> * @param  int[optional] $data_type<br /> * @return bool<br /> */<br /> public function bindValue($parameter, $value, $data_type = PDO::PARAM_STR)<br /> {<br /> return parent::bindValue($parameter, $value, $data_type);<br /> }<br /> <br /> /**<br /> * Closes the cursor, enabling the statement to be executed again<br /> *<br /> * @access public<br /> * @return bool<br /> */<br /> public function closeCursor()<br /> {<br /> return parent::closeCursor();<br /> }<br /> <br /> /**<br /> * Returns the number of columns in the result set<br /> *<br /> * @access public<br /> * @return int<br /> */<br /> public function columnCount()<br /> {<br /> return parent::columnCount();<br /> }<br /> <br /> /**<br /> * Dump a SQL prepared command<br /> *<br /> * @access public<br /> */<br /> public function debugDumpParams()<br /> {<br /> return parent::debugDumpParams();<br /> }<br /> <br /> /**<br /> * Executes a prepared statement <br /> *<br /> * @access public<br /> * @param  array $input_parameters<br /> * @return bool<br /> */<br /> public function execute($input_parameters = array())<br /> {<br /> return parent::execute($input_parameters);<br /> }<br /> <br /> /**<br /> * Fetches the next row from a result set<br /> *<br /> * @access public<br /> * @param  int[optional] $fetch_style<br /> * @param  int[optional] $cursor_orientation<br /> * @param  int[optional] $cursor_offset<br /> * @return mixed<br /> */<br /> public function fetch($fetch_style = PDO::FETCH_BOTH, $cursor_orientation = PDO::FETCH_ORI_NEXT, $cursor_offset = 0)<br /> {<br /> return parent::fetch($fetch_style, $cursor_orientation, $cursor_offset);<br /> }<br /> <br /> /**<br /> * Returns an array containing all of the result set rows<br /> *<br /> * @access public<br /> * @param  int[optional] $fetch_style<br /> * @param  int[optional] $column_index<br /> * @param  array         $ctor_args <br /> * @return array<br /> */<br /> public function fetchAll($fetch_style = PDO::FETCH_BOTH, $column_index = 0 , $ctor_args = array())<br /> {<br /> return parent::fetchAll($fetch_style, $column_index, $ctor_args);<br /> }<br /> <br /> /**<br /> * Returns a single column from the next row of a result set<br /> *<br /> * @access public<br /> * @param  int[optional] $column_number<br /> * @return string<br /> */<br /> public function fetchColumn($column_number = 0)<br /> {<br /> return parent::fetchColumn($column_number);<br /> }<br /> <br /> /**<br /> * Fetches the next row and returns it as an object<br /> *<br /> * @access public<br /> * @param  string[optional] $class_name<br /> * @param  array            $ctor_args<br /> * @return mixed<br /> */<br /> public function fetchObject($class_name = 'stdClass', $ctor_args = null)<br /> {<br /> return parent::fetchObject($class_name, $ctor_args);<br /> }<br /> <br /> /**<br /> * Retrieve a attribute<br /> *<br /> * @access public<br /> * @param  int $attribute<br /> * @return mixed<br /> */<br /> public function getAttribute($attribute)<br /> {<br /> return parent::getAttribute($attribute);<br /> }<br /> <br /> /**<br /> * Returns metadata for a column in a result set<br /> *<br /> * @access public<br /> * @param  int $column<br /> * @return array<br /> */<br /> public function getColumnMeta($column)<br /> {<br /> return parent::getColumnMeta($column);<br /> }<br /> <br /> /**<br /> * Advances to the next rowset in a multi-rowset statement handle<br /> *<br /> * @access public<br /> * @return bool<br /> */<br /> public function nextRowset()<br /> {<br /> return parent::nextRowset();<br /> }<br /> <br /> /**<br /> * Returns the number of rows affected by the last SQL statement<br /> *<br /> * @access public<br /> * @return int the number of rows. <br /> */<br /> public function rowCount()<br /> {<br /> return parent::rowCount();<br /> }<br /> <br /> /**<br /> * Set the default fetch mode for this statement<br /> *<br /> * @access public<br /> * @param  $PDO<br /> * @param  object $object <br /> * @return bool <br /> */<br /> public function setFetchMode()<br /> {<br /> $args = func_get_args();<br /> switch(func_num_args()) {<br /> case 1:<br /> return parent::setFetchMode($args[0]);<br /> break;<br /> case 2:<br /> return parent::setFetchMode($args[0], $args[1]);<br /> break;<br /> case 3:<br /> return parent::setFetchMode($args[0], $args[1], $args[2]);<br /> break;<br /> }<br /> }<br /> <br /> /**<br /> * Prevent users to clone the instance<br /> *<br /> * @access public<br /> * @return string trigger_error<br /> */<br /> public function __clone()<br /> {<br /> trigger_error('Clone is not allowed.', E_USER_ERROR);<br /> }<br /> }<br /> ?>

Ventaja

Si en un futuro, encontramos otra capa de abstracción que se adapte más a nuestro contexto (rendimiento, flexibilidad, simplicidad, etc), podremos reemplazarla, sin que la lógica de nuestra aplicación se vea afectada por el cambio, (nuestra lógica depende de nuestra clase Database, y no concretamente de una capa de abstracción específica).

Artículos Relacionados

Bibliografía

Enrique Place, (25 de mayo del 2006). «Comentarios sobre: "¿Cual es la mejor capa de abstracción?"». Consultado el 1 de diciembre de 2009.

PDO (PHP Data Objects). Capa de Abstracción de acceso a Bases de Datos utilizando el Patrón de diseño Singleton (Segunda parte)

2009-11-20T07:38:00.008+01:00

Como crear una Capa de Abstracción de acceso a Bases de Datos utilizando la extensión PDO y el Patrón de diseño Singleton.

Es decir, crearemos una clase Database que usara internamente PDO y el Patrón Singleton.

Ejemplo

Database.php

view plain copy to clipboard print ?

<?php
require_once 'web.config.php';
final class Database
{
private static $dns = DNS;
private static $username = USERNAME;
private static $password = PASSWORD;
private static $instance;
private function __construct() { }
/**
* Crea una instancia de la clase PDO
*
* @access public static
* @return object de la clase PDO
*/
public static function getInstance()
{
if (!isset(self::$instance))
{
self::$instance = new PDO(self::$dns, self::$username, self::$password);
self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
return self::$instance;
}
/**
* Impide que la clase sea clonada
*
* @access public
* @return string trigger_error
*/
public function __clone()
{
trigger_error('Clone is not allowed.', E_USER_ERROR);
}
}
?>

<?php<br /> require_once 'web.config.php';<br /> <br /> final class Database<br /> {<br /> private static $dns       = DNS;<br /> private static $username  = USERNAME;<br /> private static $password  = PASSWORD;<br /> private static $instance;<br /> <br /> private function __construct() { }<br /> <br /> /**<br /> * Crea una instancia de la clase PDO<br /> * <br /> * @access public static<br /> * @return object de la clase PDO<br /> */<br /> public static function getInstance()<br /> {<br /> if (!isset(self::$instance))<br /> {<br /> self::$instance = new PDO(self::$dns, self::$username, self::$password);<br /> self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);<br /> }<br /> return self::$instance;<br /> }<br /> <br /> <br /> /**<br /> * Impide que la clase sea clonada<br /> * <br /> * @access public<br /> * @return string trigger_error<br /> */<br /> public function __clone()<br /> {<br /> trigger_error('Clone is not allowed.', E_USER_ERROR);<br /> }<br /> }<br /> ?>

web.config.php

view plain copy to clipboard print ?

<?php
define('DNS','mysql:dbname=midbname;host=mihost');
define('USERNAME','miusername');
define('PASSWORD','mipassword');
?>

<?php<br /> define('DNS','mysql:dbname=midbname;host=mihost');<br /> define('USERNAME','miusername');<br /> define('PASSWORD','mipassword');<br /> ?>

test.php

view plain copy to clipboard print ?

<?php
/* 1. Conexión a la base de datos */
require_once 'Database.php';
$dbh = Database::getInstance();
/* Creación de la base de datos noticias */
$dbh->query('CREATE DATABASE `noticias`
DEFAULT CHARACTER SET
latin1 COLLATE latin1_swedish_ci');
$dbh->query('USE `noticias`');
/* Creación la tabla noticias */
$dbh->query('CREATE TABLE IF NOT EXISTS `noticia` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`titulo` varchar(50) NOT NULL,
`texto` varchar(500) NOT NULL,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARSET=utf8 AUTO_INCREMENT=2');
/* Insertando datos en la tabla noticias */
$dbh->query("INSERT INTO `noticia` (`titulo`, `texto`)
VALUES ('PHP5 ', 'PHP5 y la POO.')");
/* 2. Enviar la instrucción SQL a la base de datos */
$resulset = $dbh->query('SELECT `titulo`,`texto`
FROM `noticia`
ORDER BY `titulo`');
/* 3. Obtener y procesar los resultados */
$noticia = $resulset->fetchObject();
echo $noticia->titulo;
echo $noticia->texto;
?>

<?php<br /> /* 1. Conexión a la base de datos */<br /> <br /> require_once 'Database.php';<br /> $dbh = Database::getInstance();<br /> <br /> /* Creación de la base de datos noticias */<br /> <br /> $dbh->query('CREATE DATABASE `noticias`<br /> DEFAULT CHARACTER SET<br /> latin1 COLLATE latin1_swedish_ci');<br /> $dbh->query('USE `noticias`');<br /> <br /> /* Creación la tabla noticias */<br /> <br /> $dbh->query('CREATE TABLE IF NOT EXISTS `noticia` (<br /> `id` int(11) NOT NULL AUTO_INCREMENT,<br /> `titulo` varchar(50) NOT NULL,<br /> `texto` varchar(500) NOT NULL,<br /> PRIMARY KEY (`id`)<br /> )<br /> ENGINE=InnoDB<br /> DEFAULT CHARSET=utf8 AUTO_INCREMENT=2');<br /> <br /> /* Insertando datos en la tabla noticias */<br /> <br /> $dbh->query("INSERT INTO `noticia` (`titulo`, `texto`)<br /> VALUES ('PHP5 ', 'PHP5 y la POO.')");<br /> <br /> /* 2. Enviar la instrucción SQL a la base de datos */<br /> <br /> $resulset = $dbh->query('SELECT   `titulo`,`texto` <br /> FROM     `noticia`<br /> ORDER BY `titulo`');<br /> <br /> /* 3. Obtener y procesar los resultados */<br /> <br /> $noticia = $resulset->fetchObject();<br /> echo $noticia->titulo;<br /> echo $noticia->texto;<br /> ?>

Artículos relacionados

PDO (PHP Data Objects). Capa de Abstracción de acceso a Bases de Datos (Primera parte)

2009-10-07T19:45:00.005+02:00

PDO (PHP Data Objects) es una extensión nativa de PHP5, consiste en una interface uniforme para acceder a varias bases de datos. PDO provee una capa de abstracción de acceso a bases de datos (BD), que permite al desarrollador abstraerse de la BD de una aplicación. Así, si en alguna fase de desarrollo del proyecto se necesita cambiar de BD, esto no afectaría la lógica de la aplicación.

Actualmente los siguientes drivers implementan la Interface PDO:

Nombre del Driver --------- Base de Datos soportadas
PDO_DBLIB ------------------ FreeTDS / Microsoft SQL Server / Sybase
PDO_FIREBIRD -------------- Firebird/Interbase 6
PDO_IBM --------------------- IBM DB2
PDO_INFORMIX ------------- IBM Informix Dynamic Server
PDO_MYSQL ----------------- MySQL 3.x/4.x/5.x
PDO_OCI ---------------------- Oracle Call Interface
PDO_ODBC ------------------- ODBC v3 (IBM DB2, unixODBC and win32 ODBC)
PDO_PGSQL ------------------ PostgreSQL
PDO_SQLITE ----------------- SQLite 3 and SQLite 2
PDO_4D ---------------------- 4D

Acceso a bases de datos en PHP5 con PDO

La extensión php_pdo para el trabajo con bases de datos esta compuesta por tres clases:

PDO: Representa una conexión entre PHP y un servidor de bases de datos.
PDOStatement: Representa una instrucción preparada y después que la instrucción es ejecutada, una result set.
PDOException: Representa un error lanzado por PDO.

La clase PDO

Sinopsis

2  PDO {
3  __construct ( string $dsn [, string $username
[, string $password [, array $driver_options ]]] )
4  bool          beginTransaction ( void )
5  bool          commit ( void )
6  mixed         errorCode ( void )
7  array         errorInfo ( void )
8  int           exec ( string $statement )
9  mixed         getAttribute ( int $attribute )
10  array        getAvailableDrivers ( void )
11  string       lastInsertId ([ string $name = NULL ] )
12  PDOStatement prepare ( string $statement 
[, array $driver_options = array() ] )
13  PDOStatement query ( string $statement )
14  string       quote ( string $string 
[, int $parameter_type = PDO::PARAM_STR ] )
15  bool         rollBack ( void )
16  bool         setAttribute ( int $attribute , mixed $value )
17  }

Métodos

PDO::beginTransaction — Inicializa una transacción.
PDO::commit — Commits una transacción.
PDO::__construct — Crea una instancia PDO que representa una conexión a una base de datos.
PDO::errorCode — Recupera el SQLSTATE asociado con la última operación en la base de datos.
PDO::errorInfo — Recupera información extendida del error asociado con la ultima operación en la base de datos.
PDO::exec — Ejecuta una instrucción SQL y retorna el número de filas afectadas.
PDO::getAttribute — Recupera un atributo de conexión a base de dato.
PDO::getAvailableDrivers — Retorna un array (arreglo) de los drivers disponibles en la extensión PDO.
PDO::lastInsertId — Retorna el ID (identificador) de la última fila insertada o secuencia de valores.
PDO::prepare — Prepara una instrucción para ejecución y retorna un objeto de tipo PDOStatement.
PDO::query — Ejecuta una instrucción SQL, retornando un resul set como un objeto de tipo PDOStatement.
PDO::quote — Quotes (Pone entre comillas simples un string) para uso en una query (consulta).
PDO::rollBack — Rolls back una transacción.
PDO::setAttribute — Modifica un atributo.

La clase PDOStatement

Sinopsis

2  PDOStatement implements Traversable {
3  bool    bindColumn ( mixed $column , mixed &$param 
[, int $type [, int $maxlen [, mixed $driverdata ]]] )
4  bool    bindParam ( mixed $parameter , mixed &$variable 
[, int $data_type [, int $length
[, mixed $driver_options ]]] )
5  bool    bindValue ( mixed $parameter , mixed $value 
[, int $data_type ] )
6  bool    closeCursor ( void )
7  int     columnCount ( void )
8  bool    debugDumpParams ( void )
9  string  errorCode ( void )
10 array   errorInfo ( void )
11 bool    execute ([ array $input_parameters = array() ] )
12 mixed   fetch ([ int $fetch_style = PDO::FETCH_BOTH
      [, int $cursor_orientation = PDO::FETCH_ORI_NEXT 
[, int $cursor_offset = 0 ]]] )
13 array   fetchAll ([ int $fetch_style = PDO::FETCH_BOTH 
[, int $column_index [, array $ctor_args = array() ]]] )
14  string fetchColumn ([ int $column_number = 0 ] )
15  mixed  fetchObject ([ string $class_name 
[, array $ctor_args ]] )
16  mixed  getAttribute ( int $attribute )
17  array  getColumnMeta ( int $column )
18  bool   nextRowset ( void )
19  int    rowCount ( void )
20  bool   setAttribute ( int $attribute , mixed $value )
21  bool   setFetchMode ( int $mode )
22  }

Métodos

PDOStatement->bindColumn — Sustituye el valor de una columna de la base de datos a una variable PHP.
PDOStatement->bindParam — Sustituye el valor de un parámetro (argumento), a el nombre de variable especificada.
PDOStatement->bindValue — Sustituye un valor como parámetro.
PDOStatement->closeCursor — Cierra el cursor, habilitando la instrucción a ser ejecutada otra vez.
PDOStatement->columnCount — Retorna el numero de columnas en el result set.
PDOStatement->debugDumpParams — Dump un commando SQL preparado.
PDOStatement->errorCode — Recupera el SQLSTATE asociado con la última operación realizada en la base de datos.
PDOStatement->errorInfo — Recupera información de error extendida asociada con la ultima operación realizada en la base de datos.
PDOStatement->execute — Ejecuta una instrucción preparada.
PDOStatement->fetch — Recupera la siguiente fila de una result set.
PDOStatement->fetchAll — Retorna un array conteniendo todas las filas del resul set.
PDOStatement->fetchColumn — Retorna una única columna de la siguiente fila de un result set.
PDOStatement->fetchObject — Recupera la siguiente fila y la retorna como un objeto.
PDOStatement->getAttribute — Recupera una atributo.
PDOStatement->getColumnMeta — Retorna metadatos de una columna en un resul set.
PDOStatement->nextRowset — Avanza a la siguiente Rowset en un multi-rowset.
PDOStatement->rowCount — Retorna el numero de filas afectadas por la última instrucción SQL.
PDOStatement->setAttribute — Modifica un atributo.
PDOStatement->setFetchMode — Modifica el valor por defecto para recuperar datos de la base de datos para la instrucción actual.

Los pasos básicos para interactuar con una base de datos desde PHP son los siguientes:

1. Conectar con el servidor de bases de datos.
2. Enviar la instrucción SQL a la base de datos.
3. Obtener y procesar los resultados.

A continuación vemos los métodos concretos con los que realizaremos estas operaciones:

1. Conectar con el servidor de bases de datos (Crear el objeto PDO):

Descripción

PDO::__construct ( string $dsn [, string $username 
[, string $password [, array $driver_options ]]] )

Lista de parámetros

DNS: (Data Source Name), contiene la información requerida para conectarse a la base de datos.
username: El nombre de usuario. Este parámetro es opcional para algunos PDO drivers .
password: La contraseña. Este parámetro es opcional para algunos PDO drivers.
driver_options: Una llave=>valor del arreglo de opciones con driver de conexión especifico.

Valores retornados

En caso de éxito retorna un objeto PDO.

Errores/Excepciones

PDO::__construct() dispara un PDOException si el intento de conexión a la base de datos falla.

2. Enviar la instrucción SQL a la base de datos:

Descripción

PDOStatement PDO::query ( string $statement )

PDOStatement PDO::query ( string $statement , 
int $PDO::FETCH_COLUMN , 
int $colno )

PDOStatement PDO::query ( string $statement , 
int $PDO::FETCH_CLASS,
  string $classname ,
array $ctorargs )

PDOStatement PDO::query ( string $statement , 
int $PDO::FETCH_INTO ,
object $object )

Lista de parámetros

Instrucción SQL.

Valores retornados

PDO::query() retorna un objeto PDOStatement.

3. Obtener y procesar los resultados.

Descripción

mixed PDOStatement::fetchObject ([ string $class_name 
[, array $ctor_args ]] )

Lista de parámetros

class_name: Nombre de la clase a crear, por defecto utiliza stdClass.
ctor_args: Elementos de este arreglo son pasados al constructor.

Valores retornados

Retorna una instancia de la clase requerida, con el nombre de las propiedades correspondiente a los nombres de las columnas o false in caso de un error.

Ejemplo completo

view plain copy to clipboard print ?

<?php
/* 1. Conexión a la base de datos */
$dsn = 'mysql:dbname=noticias;host=127.0.0.1';
$user = 'dbuser';
$password = 'dbpass';
try
{
$dbh = new PDO($dsn, $user, $password);
}
catch (PDOException $e)
{
echo 'Connection failed: ' . $e->getMessage();
}
/* Creación la tabla noticias */
$dbh->query('CREATE TABLE IF NOT EXISTS `noticia` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`titulo` varchar(50) NOT NULL,
`texto` varchar(500) NOT NULL,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARSET=utf8 AUTO_INCREMENT=2');
/* Insertando datos en la tabla noticias */
$dbh->query("INSERT INTO `noticia` (`titulo`, `texto`)
VALUES ('PHP5 ', 'PHP5 y la POO.')");
/* 2. Enviar la instrucción SQL a la base de datos */
$resulset = $dbh->query('SELECT `titulo`,`texto`
FROM `noticia`
ORDER BY `titulo`');
/* 3. Obtener y procesar los resultados */
$noticia = $resulset->fetchObject();
echo $noticia->titulo;
echo $noticia->texto;
?>

<?php<br /> /* 1. Conexión a la base de datos */<br /> <br /> $dsn = 'mysql:dbname=dbtest;host=127.0.0.1';<br /> $user = 'dbuser';<br /> $password = 'dbpass';<br /> try<br /> {<br /> $dbh = new PDO($dsn, $user, $password);<br /> }<br /> catch (PDOException $e)<br /> {<br /> echo 'Connection failed: ' . $e->getMessage();<br /> }<br /> <br /> /* Creación de la base de datos noticias */<br /> <br /> $dbh->query('CREATE DATABASE `noticias` <br /> DEFAULT CHARACTER SET <br /> latin1 COLLATE latin1_swedish_ci');<br /> $dbh->query('USE `noticias`');<br /> <br /> /* Creación la tabla noticias */<br /> <br /> $dbh->query('CREATE TABLE IF NOT EXISTS `noticia` (<br /> `id` int(11) NOT NULL AUTO_INCREMENT, <br /> `titulo` varchar(50) NOT NULL, <br /> `texto` varchar(500) NOT NULL, <br /> PRIMARY KEY (`id`)<br /> ) <br /> ENGINE=InnoDB  <br /> DEFAULT CHARSET=utf8 AUTO_INCREMENT=2');<br /> <br /> /* Insertando datos en la tabla noticias */<br /> <br /> $dbh->query("INSERT INTO `noticia` (`titulo`, `texto`) <br /> VALUES ('PHP5 ', 'PHP5 y la POO.')");<br /> <br /> /* 2. Enviar la instrucción SQL a la base de datos */<br /> <br /> $resulset = $dbh->query('SELECT   `titulo`,`texto` <br /> FROM     `noticia` <br /> ORDER BY `titulo`');<br /> <br /> /* 3. Obtener y procesar los resultados */<br /> <br /> $noticia = $resulset->fetchObject();<br /> echo $noticia->titulo;<br /> echo $noticia->texto;<br /> ?>

Conclusión

PDO cumple con una premisa del diseño Orientado a Objetos:

“No dependas de implementaciones concretas, solo de implementaciones abstractas”[1]

PDO es una implementación abstracta, un paso a mejorar el performance de nuestras aplicaciones con desarrollos más portables y escalables.

Artículos relacionados

PDO (PHP Data Objects). Capa de Abstracción de acceso a Bases de Datos utilizando el Patrón de diseño Singleton (Segunda parte)

Referencias Bibliográficas

[1] Enrique Place, (mayo 25, 2006). «Comentarios sobre: "¿Cual es la mejor capa de abstracción?"». Consultado el 1 de octubre del 2009.

Bibliografía

Colaboradores de Wikipedia. Capa de abstracción [en línea]. Wikipedia, La enciclopedia libre, 2009 [fecha de consulta: 17 de julio del 2009]. Disponible en <http://es.wikipedia.org/w/index.php?title=Capa_de_abstracci%C3%B3n&oldid=28148126>.

Patrón Simple Factory en PHP5

2009-09-13T04:16:00.016+02:00

Factory Method o Simple Factory

"Clase con la responsabilidad de crear objetos de otras clases. No delega en subclases y sus métodos pueden ser estáticos. Puede evolucionar en un Abstract Factory." [1]

Clasificación del patrón

Creacional.

Intención o problema que soluciona

Centraliza en una clase constructora la creación de objetos de un subtipo de un tipo determinado, ocultando al cliente la casuística para elegir el subtipo que crear.

Motivación

Muchos de ustedes pensaran: ¿Por qué complicarme tanto la vida utilizando un patrón de diseño, en lugar de instanciarla directamente $obj = new MiClase () ?

Hay un escenario principal en el que puede resultar útil.

Flexibilidad en tiempo de ejecución: A veces es imposible elegir de antemano cuál objeto específico debe ser instanciado, ya que la elección de los objetos a utilizar puede depender de algo en el entorno de ejecución.

Aplicabilidad

Una clase no puede prever la clase de objetos que debe crear.
Centralizar la creación de objetos.
Proveer una interfaz para el cliente, permitiendo crear una familia de objetos sin especificar su clase.

Estructura

Implementación

La clase UserFactory tiene un método estático create, el cual recibe como parámetro un argumento y según el valor de este decide que clase instanciar (usualmente una subclase).

Código de Ejemplo en PHP5

Existen diferentes tipos y variantes de fábricas. En este artículo explicaré el Simple Factory.

view plain copy to clipboard print ?

interface FactoryInterface {
static public function Create($name);
}

interface UserInterface {<br /> static public function Create($name);<br /> }

view plain copy to clipboard print ?

abstract class User {
protected $name = NULL;
public function __construct($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function hasReadPermission()
{
return true;
}
public function hasModifyPermission()
{
return false;
}
public function hasDeletePermission()
{
return false;
}
public function wantsFlashInterface()
{
return true;
}
}

abstract class User {<br /> <br /> protected $name = NULL;<br /> <br /> public function __construct($name)<br /> {<br /> $this->name = $name;<br /> }<br /> <br /> public function getName()<br /> {<br /> return $this->name;<br /> }<br /> <br /> public function hasReadPermission()<br /> {<br /> return true;<br /> }<br /> <br /> public function hasModifyPermission()<br /> {<br /> return false;<br /> }<br /> <br /> public function hasDeletePermission()<br /> {<br /> return false;<br /> }<br /> <br /> public function wantsFlashInterface()<br /> {<br /> return true;<br /> }<br /> }

view plain copy to clipboard print ?

class GuestUser extends User { }

class GuestUser extends User { }

view plain copy to clipboard print ?

class CustomerUser extends User {
function hasModifyPermission()
{
return true;
}
}

class CustomerUser extends User {<br /> function hasModifyPermission()<br /> {<br /> return true;<br /> }<br /> }

view plain copy to clipboard print ?

class AdminUser extends User {
public function hasModifyPermission()
{
return true;
}
public function hasDeletePermission()
{
return true;
}
public function wantsFlashInterface()
{
return false;
}
}

class AdminUser extends User {<br /> <br /> public function hasModifyPermission()<br /> {<br /> return true;<br /> }<br /> <br /> public function hasDeletePermission()<br /> {<br /> return true;<br /> }<br /> <br /> public function wantsFlashInterface()<br /> {<br /> return false;<br /> }<br /> }

view plain copy to clipboard print ?

class UserFactory implements FactoryInterface {
private static $users = array('Arley'=>'admin', 'Michel'=>'guest',
'Derick'=>'customer');
/**
* Función de creación de usuarios. Recibe el tipo
* de usario a crear y retorna una instancia valida
*
* @access public static
* @param string $name
* @return object
*/
static public function Create($name)
{
if (!isset(self::$users[$name])) {
throw new Exception('El nombre de usuario '.$name.' es desconocido');
}
switch (self::$users[$name]) {
case 'guest': return new GuestUser($name);
case 'customer': return new CustomerUser($name);
case 'admin': return new AdminUser($name);
default:
throw new Exception('Tipo de usario desconocido');
}
}
}

class UserFactory {<br /> <br /> private static $users = array('Arley'=>'admin', 'Michel'=>'guest',<br /> 'Derick'=>'customer');<br /> <br /> /**<br /> * Función de creación de usuarios. Recibe el tipo<br /> * de usario a crear y retorna una instancia valida<br /> *<br /> * @access public static<br /> * @param  string $name<br /> * @return object<br /> */<br /> static public function Create($name)<br /> {<br /> if (!isset(self::$users[$name])) {<br /> throw new Exception('El nombre de usuario '.$name.' es desconocido');<br /> }<br /> switch (self::$users[$name]) {<br /> case 'guest': return new GuestUser($name);<br /> case 'customer': return new CustomerUser($name);<br /> case 'admin': return new AdminUser($name);<br /> default:<br /> throw new Exception('Tipo de usario desconocido');<br /> }<br /> }<br /> }

view plain copy to clipboard print ?

function boolToStr($b)
{
if ($b == true) {
return "Si\n";
} else {
return "No\n";
}
}
function displayPermissions(User $obj)
{
print $obj->getName() . ' permiso:';
print 'Lectura: ' . boolToStr($obj->hasReadPermission()).'';
print 'Modificar: ' . boolToStr($obj->hasModifyPermission()).'';
print 'Escritra: ' . boolToStr($obj->hasDeletePermission()).'';
}
function displayRequirements(User $obj)
{
if ($obj->wantsFlashInterface()) {
print $obj->getName() . ' requiere Flash ';
}
}
$logins = array('Arley', 'Michel', 'Derick');
foreach($logins as $login)
{
displayPermissions(UserFactory::Create($login));
print '';
displayRequirements(UserFactory::Create($login));
}

function boolToStr($b)<br /> {<br /> if ($b == true) {<br /> return "Si\n";<br /> } else {<br /> return "No\n";<br /> }<br /> }<br /> <br /> function displayPermissions(User $obj)<br /> {<br /> print $obj->getName() . ' permiso:</br>';<br /> print 'Lectura: ' . boolToStr($obj->hasReadPermission()).'</br>';<br /> print 'Modificar: ' . boolToStr($obj->hasModifyPermission()).'</br>';<br /> print 'Escritra: ' . boolToStr($obj->hasDeletePermission()).'</br>';<br /> }<br /> <br /> function displayRequirements(User $obj)<br /> {<br /> if ($obj->wantsFlashInterface()) {<br /> print $obj->getName() . ' requiere Flash </br></br>';<br /> }<br /> }<br /> <br /> $logins = array('Arley', 'Michel', 'Derick');<br /> <br /> foreach($logins as $login)<br /> {<br /> displayPermissions(UserFactory::Create($login));<br /> print '</br>';<br /> displayRequirements(UserFactory::Create($login));<br /> }

Otros artículos sobre Patrones

Referencias bibliográficas

[1] León Welicki, «Patrones de Fabricación: Fábricas de Objetos». Consultado el 11 de septiembre de 2009.

Patrón de diseño Decorator en PHP5

2009-09-12T06:44:00.008+02:00

Patrón Decorator responde a la necesidad de agregar funcionalidad a un objeto por medio de la asociación de clases. Es un objeto con el que se puede ejecutar funcionalidades de varias clases a la vez.

"Esto nos permite no tener que crear sucesivas clases que hereden de la primera incorporando la nueva funcionalidad, sino otras que la implementan y se asocian a la primera." [1]

Clasificación del patrón

Estructural.

Intención o problema que soluciona

"Supongamos que tenemos una clase existente Ventana y queremos añadirle funcionalidad para que muestre un borde alrededor. Podemos crear una subclase VentanaConBorde que herede de Ventana. Hasta aquí todo bien, pero supongamos que surge la necesidad de crear una ventana que muestre un pequeño botón de ayuda con un signo de interrogación (?) en su parte superior." [1]

Entonces tenemos las siguientes opciones:

1. Crear otra subclase de Ventana: VentanaConBotónDeAyuda.

Problema: No cubre la necesidad de tener ventanas con bordes y botón de ayuda a la vez.

2. Crear una subclase de VentanaConBorde: VentanaConBordeYBotonDeAyuda.

Problema: No tenemos una ventana con botón de ayuda y sin borde.
3. Crear clases para todas las combinaciones posibles de funcionalidades.

Problema: Con este ejemplo tendríamos cuatro clases: Ventana, VentanaConBorde, VentanaConBotonDeAyuda y VentanaConBordeYBotonDeAyuda; con tres funcionalidades tendríamos ocho clases y con cuatro, ¡dieciséis!.

Aplicabilidad

Añadir objetos individuales de forma dinámica y transparente.

Responsabilidades de un objeto pueden ser retiradas.

Cuando la extensión mediante la herencia no es viable.

Hay una necesidad de extender la funcionalidad de una clase, pero no hay razones para extenderlo a través de la herencia.

Hay la necesidad de extender dinámicamente la funcionalidad de un objeto y quizás quitar la funcionalidad extendida. [1]

Código de Ejemplo en PHP5

view plain copy to clipboard print ?

<?php
interface iCoffee {
public function getBaseCost();
}
class Coffee implements iCoffee {
protected $_baseCost = 0;
public function getBaseCost()
{
return $this->_baseCost;
}
}
class BlackCoffee extends Coffee {
public function __construct()
{
$this->_baseCost = 5;
}
}
abstract class CoffeeDecorator implements iCoffee {
protected $_coffee;
public function __construct(iCoffee $Coffee)
{
$this->_coffee = $Coffee;
}
}
class WithCream extends CoffeeDecorator {
public function getBaseCost()
{
return $this->_coffee->getBaseCost() + 1.5;
}
}
class WithMilk extends CoffeeDecorator {
public function getBaseCost()
{
return $this->_coffee->getBaseCost() + 4;
}
}
class WithChocolate extends CoffeeDecorator {
public function getBaseCost()
{
return $this->_coffee->getBaseCost() + 5;
}
}
$coffee = new WithChocolate(new WithMilk(new WithCream(new BlackCoffee())));
echo 'El precio del cafe es: $' . $coffee->getBaseCost();

<?php<br /> interface iCoffee {<br /> public function getBaseCost();<br /> }<br /> <br /> class Coffee implements iCoffee {<br /> protected $_baseCost = 0;<br /> public function getBaseCost()<br /> {<br /> return $this->_baseCost;<br /> }<br /> }<br /> <br /> class BlackCoffee extends Coffee {<br /> public function __construct()<br /> {<br /> $this->_baseCost = 5;<br /> }<br /> }<br /> <br /> abstract class CoffeeDecorator implements iCoffee {<br /> protected $_coffee;<br /> public function __construct(iCoffee $Coffee)<br /> {<br /> $this->_coffee = $Coffee;<br /> }<br /> }<br /> <br /> class WithCream extends CoffeeDecorator {<br /> public function getBaseCost()<br /> {<br /> return $this->_coffee->getBaseCost() + 1.5;<br /> }<br /> }<br /> <br /> class WithMilk extends CoffeeDecorator {<br /> public function getBaseCost()<br /> {<br /> return $this->_coffee->getBaseCost() + 4;<br /> }<br /> }<br /> <br /> class WithChocolate extends CoffeeDecorator {<br /> public function getBaseCost()<br /> {<br /> return $this->_coffee->getBaseCost() + 5;<br /> }<br /> }<br /> <br /> $coffee = new WithChocolate(new WithMilk(new WithCream(new BlackCoffee())));<br /> echo 'El precio del cafe es: $' . $coffee->getBaseCost();

Otros artículos sobre Patrones

Referencias bibliográficas

[1] Colaboradores de Wikipedia. Decorator (patrón de diseño) [en línea]. Wikipedia, La enciclopedia libre, 2009 [fecha de consulta: 9 de septiembre del 2009]. Disponible en <http://es.wikipedia.org/w/index.php?title=Decorator_(patr%C3%B3n_de_dise%C3%B1o)&oldid=27813809>.

Patrón Singleton en PHP5

2009-09-01T10:15:00.006+02:00

El patrón de diseño"Singleton" está diseñado para restringir la creación de objetos pertenecientes a una clase, forzando a que solo se pueda crear una única instancia, de ahí su nombre Singleton (instancia única).

Un ejemplo de uso de este patrón: supongamos que tenemos una clase "Database" y instanciamos dicha clase, la cual nos devuelve un objeto llamado "$conn", una vez creada la conexión con la base de datos esta simple instancia será fácilmente accesible a muchos otros objetos, restringiéndose así a la creación de una única instancia la cual será reutilizada una y otra vez.

¿Pero como funciona el patrón de diseño Singleton?

El patrón Singleton provee una única instancia global debido a que: si se solicita una instancia de la clase:

a) La propia clase es la responsable de crear la única instancia, la cual debe garantizar que no se pueda crear ninguna otra (interceptando todas las peticiones para crear nuevos objetos) y proporcionando un solo punto de acceso a ella.

b) Si no se ha creado anteriormente (o sea, es la primera vez que se usa esta clase) se crea la instancia.

c) Si existe ya anteriormente una instancia (es la segunda o más veces que se usa), se retorna la existente todas las veces que se solicite.

d) El constructor de la clase debe declararse como privado para que la clase no pueda ser instanciada directamente.

e) Adicionalmente en PHP5 no se permite que la clase sea clonada con el método __clone().

De esta forma forzamos a que no se puedan crear objetos de forma directa por la vía del operador "new" ejemplo:

$objeto = new Ejemplo();
//Fatal error:Call to private Ejemplo::__construct() from invalid context

Bueno llegados a este punto se pudieran preguntar

¿Entonces como creo la instancia a la clase si el constructor está declarado como privado?

Directamente a través de un método declarado como público y estático, que será el encargado de crear la instancia de la clase. Ver a continuación:

public static function getInstance() {
if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c;
}
return self::$instance;
}

Cuando declararamos atributos de clases o métodos como estáticos, los hacemos accesibles desde afuera del contexto del objeto. Utilizamos entonces el operador de resolución :: que permite el acceso a los atributos y métodos estáticos, veamos un ejemplo:

$var = NombreClase::Metodo();

Funcionamiento del método getInstance()

Primeramente accedemos al método:

$inst1 = Ejemplo::getInstance();

Como podemos ver este método verifica el estado del atributo private static $instance; si está o no definido, para así tomar la decisión de crear la instancia o retornarla directamente en caso de que ya esté creada.

Entonces existen 2 posibles casos:

Caso 1: Si no esta definido el atributo $instance se crea por primera vez la instancia, se almacena en el la referencia y se retorna.

Caso 2: De estar definido el atributo se retorna la instancia almacenada en el directamente.

Implementacion oficial del Patrón Singleton en PHP5:

Esta es la implementación oficial en PHP5 de este patrón les dejo el vinculo http://www.php.net/manual/en/language.oop5.patterns.php , lo único que he cambiado por motivos didácticos y de claridad es el nombre del método singleton() por el de getInstance().

  
class Ejemplo
{
/**
*  Contenedor de la Instancia de la Clase
*
*  @access private static
*/
private static $instance;

/**
*  Constructor
*
*  Previene la creación de objetos via $obj = new Ejemplo();
*
*  @access private
*/
private function __construct() { }

/**
* El método getInstance
*
* Crea una instancia de la clase Ejemplo
*
* @access public static
* @return object de la clase Ejemplo
*/
public static function getInstance()
{

if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c;

}

return self::$instance;
}
/**
* El método __clone()
*
* Previene que la clase sea clonada
*
* @access public
*/
public function __clone()
{
trigger_error('Clone no se permite.', E_USER_ERROR);

}
}

/**
* Ejemplo de uso
*
* Accedo directamente al método getInstance()
* para que me devuelva una instancia de la clase Ejemplo,
* como dicha instancia no existe este método, la crea.
*
* Nota: si hacemos var_dump sobre un variable esta función
* mostrará información estructurada que incluye tipos y valores.
* En el caso de las variables que contienen objetos esta funcion
* devolvería tipo de la variable, en este caso
* object, entre paréntesis (nombre de la clase) y
* un número único #id que representa al objeto creado.
* Podemos ver que dicho número #id es el mismo para estas
* dos primeros casos.
*/
$inst1 = Ejemplo::getInstance();


var_dump($inst1);
/**
* En el segundo caso, como existe ya la instancia,
* el método getInstance() lo comprueba y no la crea,
* sino que la retorna directamente.
*/
$inst2 = Ejemplo::getInstance();


var_dump($inst2);
/**
* Si intento crear una instancia directamente utilizando
* el operador new.
*
* Fatal error: Call to private Ejemplo::__construct()
* from invalid context
*/
$inst3 = new Ejemplo();

¿Ventajas y usos?

Suponiendo que utilizamos el Singleton en una Base de Datos, esto posibilita que:

1.) Que nuestra aplicación web ahorre recursos del servidor.

2.) Tenemos bien controlado la creación de objetos, al no permitir que nuestra aplicación tenga innumerable y descontroladas conexiones innecesarias abiertas a una misma base de datos.

Otros artículos sobre Patrones

Bibliografía

Enrique Place, (7 de noviembre del 2006). «Patrón de Diseño "Singleton"». Consultado el 25 de agosto de 2009.
Colaboradores de Wikipedia. Patrón de diseño [en línea]. Wikipedia, La enciclopedia libre, 2009 [fecha de consulta: 17 de septiembre del 2009]. Disponible en <http://es.wikipedia.org/w/index.php?title=Patr%C3%B3n_de_dise%C3%B1o&oldid=29814016>.
Colaboradores de Wikipedia. Singleton [en línea]. Wikipedia, La enciclopedia libre, 2009 [fecha de consulta: 1 de septiembre del 2009]. Disponible en <http://es.wikipedia.org/w/index.php?title=Singleton&oldid=29359982>.