Cómo hacer una API REST con Node.js

En artículos anteriores hemos visto cómo hacer la primera configuración de las herramientas que vamos a instalar así como a organizar nuestro proyecto utilizando el patrón Modelo-Vista-Controlador. Pues bien, hoy toca entrar en materia y vamos a comenzar a hacer una API REST con Node.js.

Un primer paso necesario para seguir estudiando Node.js y una buena base para que después podamos crear una aplicación SPA, o consultar la API desde un proyecto Symfony o para hacer que nuestra aplicación móvil pueda explotar esos datos oooo yo que sé…. las posibilidades son infinitas así que empecemos!

Cómo hacer una API REST con Node.js

A lo mejor a mas de uno esto de hacer una API REST con Node le suena a chino así que lo mejor que podemos hacer es ver primeramente qué es eso de una API REST.

¿Qué es una API REST?

Pues es lo que se conoce como una interfaz de comunicación entre clientes que utilicen el protocolo HTTP. Para que se entienda, es el canal por el cual tu móvil le dice a los servidores de Clash Royale que has abierto un cofre y te ha tocado el mago eléctrico o por ejemplo es el canal que utiliza Instragram para subir las fotos que haces con tu smartphone a sus servidores.

¿Se entiende el concepto?

Hoy en día podemos encontrar usos de APIs en casi toda cosa tecnológica que nos imaginemos pero el concepto de API no es nuevo ya que hace años existía otro tipo de APIs que parecía ser el rey del desarrollo. Hablo de SOAP y su intercambio de datos mediante XML. Hasta que debido a su facilidad llegaron las API REST y el intercambio mediante JSON.

Principalmente con una API REST vamos a echar mano de lo que se conoce como verbos HTTP. En concreto 4 y cada uno de estos verbos los utilizaremos para una acción u operación diferente con los datos que queremos manipular.

Así pues:

  • Cuando queramos subir una imagen nueva a Instragram utilizaremos el método POST del protocolo HTTP.
  • Cuando queramos saber cuántos seguidores tenemos en Twitter utilizaremos el método GET del protocolo HTTP.
  • Cuando queramos eliminar nuestro último estado de Facebook utilizaremos el método DELETE del protocolo HTTP.
  • Cuando queramos actualizar la foto de perfil de Snapchat utilizaremos el método PUT del protocolo HTTP.
  • Cuando queramos ver la lista de seguidores de VK utilizaremos el método GET del protocolo HTTP.

Hasta aquí esto es lo mínimo que podemos hacer con una API REST pero si quieres saber mas te recomiendo que le eches un vistazo a este artículo en el que se explica muy bien toda esta película, que nosotros nos vamos a poner a hacer ya una API REST con Node.js 😀

Cuatro verbos para dominarlos a todos

¿Os acordáis de la aplicación sobre álbumes musicales que empezamos a crear en los artículos anteriores? Si no te acuerdas o todavía no los has visto retrocede un poquito en el tiempo desde este enlace y desde este y cuando los hayas terminado vuelve aquí para seguir con la API REST con Node.js

Pero para el que si que se acuerde mediante el patrón MVC llegamos a organizar los ficheros de nuestro proyecto de una forma lógica y funcional ¿no?

También te acordarás de que hicimos un pequeño controlador para probar ¿no? De hecho llegamos a definir los métodos mínimos que tiene que tener nuestra API pero la gran mayoría de estos métodos lo único que hacia era recibir los datos de la request y devolverlos en la response. No había lógica de negocio alguna.

Pues ha llegado el momento de darle cuerpo a esos métodos 🙂

Método GET, consultar datos en una API REST con Node.js

Este es el primer verbo que vamos a ver de nuestra API REST con Node.js y es que tiene dos aplicaciones. Por un lado podemos utilizarlo para que nos devuelva un listado de elementos y por otro lado si le pasamos un identificador (lo mas normal debido a su unicidad) obtendremos los datos de un solo registro.

Aclaro que no es necesario pasar un id, podemos pasarle cualquier parámetro aunque en los métodos tipo getBy lo mas normal es pasarle el identificador.

Fijaos, aquí tenemos el ejemplo de estos dos métodos GET de la API y que nos devolverán ya sea un elemento o varios elementos. Pero hay varias cosas importantes que explicar:

  1. Hay que incluir el modelo, eso se hace en la primera línea del código anterior mediante un require.
  2. Mediante la sentencia req.params.id de la linea 4 estamos accediendo al valor que le pasamos a la ruta como parámetro.
  3. En la línea 6 encontramos el método findById() que es definido por el ORM de Mongoose y que nos provee de una capa de abstracción para explotar datos. Este método acepta el identificador que ha de buscar y una función de callback.
  4. Línea 20 encadenamos el método find() y el método de ordenación sort(). Si al método find() no le pasamos ningún argumento tan solo un objeto vacío por defecto nos sacará todos los registros de ese modelo de nuestra base de datos. Por otro lado, el método sort() espera un argumento por el cual ordenar el listado.

Estos dos métodos de nuestra API matchearán con las siguientes rutas (recuerda, has de tenerlas definidas)

Método POST, guardar datos en una API REST con Node.js

Bien, el siguiente método que vamos a construir es el que se encarga de guardar datos y va a ir por POST.

  • Si antes accedíamos a los argumentos pasados por GET en la ruta mediante la sentencia req.params.id, ahora para obtener los valores pasados por el método POST tenemos que hacer uso de la sentencia req.body (línea 3)
  • Seteamos los valores de la instancia del modelo con lo que nos ha traído la petición POST de la línea 5 a la línea 8.
  • Hacemos uso del método definido por Mongoose save() para guardar estos datos. Este método acepta una función de callback que recibirá el error en caso de producirse o el objeto ya almacenado.
  • Lo demás es hacer unas comprobaciones mínimas para asegurar la integridad de los datos y a correr 🙂

Método PUT, actualizar datos en una API REST con Node.js

Este es el método de nuestra API que se va a encargar de actualizar datos.

  • Va a recibir los datos a actualizar mediante POST (línea 2)
  • Va a recibir el identificador del objeto a actualizar mediante GET, a través de la URL (línea 3)
  • El método findByIdAndUpdate() nos es provisto por el ORM Mongoose y acepta el identificador del objeto a actualizar, los datos a actualizar y una función de callback con el error (si es que hay alguno) y el objeto ya actualizado.

He de aclarar que gracias al middleware body-parser y que ya aprendimos a instalar en los artículos anteriores, todo lo que nos llegue por POST es transformado en objeto automáticamente, así podemos manipular los parámetros de una forma bien sencilla.

La URL definida para este método ha de ser de la siguiente forma:

Método DELETE, borrar datos en una API REST con Node.js

El último método del CRUD de nuestra API REST con Node.js es el método que se va a encargar de borrar y que funciona a través del método DELETE del protocolo HTTP.

  • Este método aceptará un único argumento que se pasa por la URL (el identificador del objeto) y que recogemos mediante la sentencia req.params.id (línea 2)
  • Gracias al ORM Mongoose podemos hacer uso del método findById() para encontrar el objeto que coincida con el identificador pasado por parámetro (línea 4).
  • Gracias al método remove() podemos eliminar el objeto solicitado (línea 9)

Con esto ya tenemos los 5 métodos necesarios para que el CRUD de nuestra API REST con Node.js funcione pero claro, necesitamos un modelo de datos para que transforme los datos que recibimos en objetos que podamos manejar mas facilmente.

Ademas que realmente el modelo es necesario para que corran los códigos anteriores…. 😛

Ea ahí tenéis el modelo de datos. Ese fichero ha de situarse en el directorio de models según la definición del patrón Modelo-Vista-Controlador y que aprendimos en el artículo anterior.

Vale Gorka, ya hemos aprendido a construir una API REST con Node.js perfecto, pero ahora… ¿cómo la probamos?

Pueeees para probar la API vamos a hacer uso de una extensión muy buena que se llama Postman y que podemos descargar desde aquí si utilizas Chrome.

He grabado un vídeo para que veáis cómo se usa.

Anuncios

Aprende a utilizar mongodb en node js como un PRO

Las bases de datos relacionales son para pussies. Muerte a MySQL y que vivan las bases de datos NoSQL. Si las grandes tecnológicas dieron el salto en su día por algo será y hoy vamos a aprender a utilizar MongoDB en Node JS!!

Jajajaja realmente la afirmación anterior no es tan tajante, no te vayas a pensar que las bases de datos relacionales han muerto para dar paso a este nuevo tipo de concepción. Eso es falso y si hay algún recruitmen de consultora que te lo dice huye rápido de su despacho.

Estos dos tipos de bases de datos están pensadas para solucionar problemas diferentes. Ya hice un artículo en el que hablaba de las diferencias entre MySQL y MongoDB y que puedes leer aquí así que échale un vistazo antes de utilizar MongoDB en Node JS 😉

Cómo instalar MongoDB en nuestra máquina

El primer paso como es lógico será instalar MongoDB en nuestra máquina. No quiero entrar mucho en detalle porque en la página de la comunidad de mongodbspain esta muy bien explicado así que me voy a limitar a dejar los enlaces:

Una vez lo tengas instalado hay un punto clave que tienes que tener en cuenta.

Para utilizar MongoDB en tu máquina es necesario que el demonio esté ejecutándose. Obviamente al igual que con otras bases de datos pero con MongoDB lo tienes que levantar tu mismo.

En la documentación de mongodbspain está profundamente ampliado pero quédate con los siguientes comandos:

$ mongod --config /usr/local/etc/mongod.conf

Este comando ejecuta el demonio y si le añades el flag –fork harás que mongo corra en segundo plano.

$ mongod --config /usr/local/etc/mongod.conf --fork

Si quieres hacer que mongo se ejecute de manera automática cuando enciendes el ordenador lanza los siguientes comandos.

//Iniciar el proceso principal mongod de MongoDB al iniciar sesión:
$ ln -sfv /usr/local/opt/mongodb/*.plist ~/Library/LaunchAgents
 
//Iniciar MongoDB ahora en background y dejarlo en ejecución
$ launchctl load ~/Library/LaunchAgents/homebrew.mxcl.mongodb.plist

Bien, con esto anterior ya habrás configurado esta base de datos no relacional y orientada a objetos en tu máquina. Ahora viene lo divertido y vamos a ver como utilizar MongoDB en Node JS.

Cómo utilizar MongoDB en Node JS

El primer paso para utilizar mongodb en node js es crearnos una base de datos, para ello abrimos una terminal y escribimos mongo. Esto nos conectará con el sistema de base de datos.

A diferencia con MySQL en la que para crear una nueva base de datos teníamos que pelearnos con los CREATE TABLE y definir una estructura con MongoDB eso no pasa.

Una vez conectados tenemos que indicar que queremos usar una base de datos e insertar un registro para que el sistema la construya on-the-fly. Sigue los pasos 😉

$ mongo
> use base-de-datos-de-prueba
> db.albums.insert({id: 1, band: 'Las Bistecs', album:'Oferta'});

Con esto ya habremos creado la base de datos y habremos insertado un nuevo registro en la colección de albums.

Vale ya tenemos lo básico pero… ¿cómo hacemos para conectar MongoDB con Node JS?

Pues eso lo vamos a hacer utilizando Mongoose que es un ORM.

Para el que no conozca qué son y cómo funcionan los ORM le dejo este enlace de la Wikipedia.

Conectar MongoDB a Node JS mediante Mongoose

Para ello vamos a instalar Mongoose tirando del gestor de dependencias NPM. Así pues en la terminal escribimos lo siguiente:

$ npm install mongoose --save

Ya sabéis, el flag –save para que guarde una copia en el directorio node_modules y actualice el package.json.

Una vez se haya instalado deberías tener el entrypoint de tu aplicación node parecido al que voy a poner a continuación. (En el post anterior expliqué cómo organizar un proyecto con node js y qué es eso del entrypoint, échale un vistazo desde aquí)

  • Línea número 3: incluímos el módulo mongoose para poder utilizarlo dentro de nuestra aplicación.
  • Línea número 8: hacemos uso del método connect. Este método acepta dos argumentos. El primero es la cadena de conexión a dónde tenemos que conectarnos y el segundo es la función callback. Fíjate en la cadena de conexión. Lo primero que hay que indicar es el protocolo (mongodb en este caso), después el nombre del host donde esté la base de datos (localhost, nuestra máquina local en este caso), después el puerto por defecto de MongoDB (27017 en este caso) y por último la base de datos a la que queremos conectarnos (base-de-datos-de-prueba en este caso)
  • Línea número 9: comprobamos si ha habido algún error de conexión y en caso contrario levantamos el servidor node

Y ya está, eso es todo.

Con esto ya podrás utilizar MongoDB en Node JS, es lo mínimo en cuanto a configuración se refiere. En el próximo artículo veremos cómo hacer las operaciones típicas de lectura, escritura, actualización y borrado sobre nuestro proyecto.

Y ya sabéis, si tenéis algún tipo de dudas o preguntas hacédmelas llegar en la sección de comentarios o a través del siguiente banner de Twitter.

[xyz-ips snippet=”FAQS-GORKAMU-TW-YELLOW”]

Hala a cascarla!

Cómo organizar un proyecto Node.js según MVC

Que Node.js sea una moda de desarrollo (esperemos que haya venido para quedarse) no lo discute nadie y como no podía ser de otra forma en esta serie de artículos vamos a aprender a trabajar con este entorno. Ya hemos visto los conceptos básicos en un post previo pero en este nuevo artículo vamos a ver como organizar un proyecto node.js siguiendo un patrón de diseño muuuuy conocido, el MVC.

Cómo organizar un proyecto Node.js de la mejor forma

Antes de entrar en materia deberías saber qué son los patrones de diseño.

Un patrón de diseño es un conjunto de reglas que nos indican cómo tenemos que organizar los ficheros de un proyecto para que este sea efectivo, reutilizable y escalable y siempre buscando la solución a un problema dado.

Existen miles de patrones de diseño diferentes y cada uno se ajusta a una casuística dada pero pongo la mano en el fuego si digo que en el ámbito del desarrollo web el que mas se utiliza es el patrón MVC.

Todos los que trabajamos con frameworks web como podrían ser Spring, Symfony o Angular (por citar diferentes tecnologías…) sabemos qué es el patrón Modelo-Vista-Controlador pero si has caído nuevo en este artículo y no sabes muy bien de que te hablo te recomiendo que le eches un vistazo a esta página de la Wikipedia.

Una vez que te hayas leído la entrada y entiendas el concepto de patrón MVC vamos a empezar a organizar nuestro proyecto Node.js 🙂

Definiendo la estructura básica de la aplicación

Deja de preguntarte ya cómo organizar un proyecto Node.js y dirígete al directorio que contendrá tu aplicación.

Ahí inicializaremos el proyecto con el comando npm init con el objetivo de crear el package.json que definirá toda nuestra aplicación. Cuando el comando termine y tengamos los ficheros básicos creados vamos a montar los siguientes directorios: /controllers,  /models y /routes

  • Directorio controllers: aquí guardaremos los ficheros que se encargarán de controlar cada parte de nuestra aplicación. Tenemos que ser capaces de abstraernos y saber atomizar la app y en consecuencia crear un controlador para cada una de estas partes. Los controladores contendrán la lógica de negocio.
  • Directorio models: en este directorio vamos a guardar lo que son los modelos de datos de la aplicación. Si tu aplicación trata sobre discos de música aquí crearemos una entidad con todas sus propiedades y métodos. Es lo que en Symfony se conoce como Entidad, en Java una POJO y en PHP una POPO.
  • Directorio routers: para hacer mas mantenible la exposición de rutas de cada controlador de tu aplicación en este directorio vamos a guardar la definición de estas rutas. Piensa que si estas construyendo una API a poco que sigas el modelo de API Restful como mínimo vas a tener 4 rutas por cada controlador (método GET, método POST, método PUT y método DELETE)

Una vez creados los directorio mínimos pasaremos a crear el fichero entrypoint (index.js) y el fichero de configuración de la aplicación.

En el fichero que hace la función de punto de entrada de nuestra aplicación, el fichero index.js, vamos a poner la configuración del servidor y a levantarlo.

Pero… y ¿cómo podemos hacer que este fichero “llame a otros”?

Pues como se ve en la línea numero 3 del script haciendo uso del require le estamos indicando a node que queremos que nos cargue el core de nuestra aplicación pero con esto no es suficiente ya que tenemos que indicar algo mas que veremos a continuación.

Este fichero es en el que configuraremos todos los aspectos de nuestra aplicación.

Como puedes leer, en el script estamos cargando el framework express, cargamos el middleware body-parser y si te fijas en la línea 7 cargamos el archivo de rutas.

A raíz de la pregunta anterior, si queremos hacer que un fichero “llame a otro”, a parte de hacer uso de la sentencia require en el fichero destino tenemos que exportarlo mediante el mecanismo de module.exports (última línea)

Una vez exportado ya podremos utilizarlo en cualquier parte de la app siempre y cuando lo carguemos con require.

Vale, hasta aquí todo correcto. Vamos a ver ahora como organizar un proyecto Node.js con sus rutas, sus controladores y sus modelos de datos.

Definiendo uno de los controladores de nuestra app

El controlador es el encargado de contener toda la lógica de negocio de nuestra aplicación. Tiene que actuar como una caja negra, le entran unos datos, los procesa y nos devuelve otros datos.

Hay varias formas de plantear y crear un controlador pero para el ámbito organizativo (no programático) de este artículo vamos a hacer funciones en lugar de clases, solo tenemos un controlador.

Fíjate en la estructura y no en el código, de hecho hace mas bien poco o nada.

Este es sería un controlador típico en un modelo de CRUD en el que implementamos las cuatro operaciones típicas, lectura de datos, creación, actualización de datos y borrado.

Cada función de este controlador hará una tarea diferente por lo que decimos que serán funciones atómicas.

Peeeeero lo importante de toda esta película esta al final del script. Fíjate que al igual que hacíamos en el fichero app.js, en este estamos exportando las funciones que nos interesan para que puedan ser llamadas desde otro fichero, como por ejemplo desde el fichero de definición de rutas.

pERO CUANTAS RUTAS TIENE ESTE TIO???

Ha llegado el momento de definir las rutas de nuestra aplicación.

Y al igual que en el fichero anterior habíamos creado cuatro funciones (bueno en realidad 5 pero dos de ellas internamente sirven para lo mismo, getAlbum y getAlbums, lectura de datos) ahora vamos a crear también 4 rutas y cada una de ellas matcheará con un método HTTP diferente.

Para que no te pierdas este va a ser el esquema de la relación métodos HTTP (API Restful) y funciones:

  • Método GET -> getAlbum() y getAlbums()
  • Método POST -> saveAlbum()
  • Método PUT -> updateAlbum()
  • Método DELETE -> delteAlbum()

Lo mas importante y lo primero de todo es crear el fichero album.js en el directorio de /routes.

Mira bien:

  • Línea número 3: cargamos el framework express.
  • Línea número 4: cargamos el controlador de álbum.
  • Línea numero 5: nos traemos el sistema para definir rutas del framework.
  • Línea 7: definimos una ruta GET para la función getAlbum().
  • Línea 8: definimos una ruta GET para la función getAlbums().
  • Línea 9: definimos una ruta POST para la función saveAlbum().
  • Línea 10: definimos una ruta PUT para la función updateAlbum().
  • Línea 11: definimos una ruta DELET para la función deleteAlbum().

Y con esto ya tendríamos la estructura básica y el artículo montado sobre como organizar un proyecto Node.js.

Por supuesto que faltan muchas cosas, de primeras el modelo de datos (eso lo dejaré para cuando empecemos con MongoDB) pero podríamos meter un directorio para la realización de test unitarios, otro para las vistas en caso en que quisiéramos ampliar la API… otro para utilidades, no sé…

El patrón MVC mínimo sería este, a partir de aquí tu ya Feel Free

Y nada, si tenéis algún tipo de preguntas no dudéis en hacérmelas llegar en los comentarios o a través del siguiente banner de Twitter.

[xyz-ips snippet=”FAQS-GORKAMU-TW-YELLOW”]

Hala a cascarla!

Aprender Node.js – Realizar el primer setup inicial

Toca renovarse. Después de muchos años usando una tecnología es normal que te hayas podido quedar un poquito estancado en cuanto a los referentes del mercado aunque por otro lado es muy seguro que hayas conseguido dominar esa tecnología y hoy vamos a empezar a aprender Node.js.

En el mundo tecnológico existe una máxima que dice que aproximadamente cada dos años se duplica el número de transistores que soporta un microprocesador. Hablo de la Ley de Moore. Esto es vertiginoso, trata de imaginar lo que supone, la tecnología avanza a pasos exponenciales y con las tendencias de desarrollo pasa casi lo mismo.

Lo que hoy sirve para desarrollar mañana ya no y por eso es muy importante que no caigamos en nuestra zona de comfort y salgamos a aprender lenguajes y tecnologías nuevas.

Por eso el sentido de estos artículos, vamos a aprender a programar con Node.js bajo una configuración de MEAN Stack y para que no nos perdamos empezaremos por el principio de todo.

¿Qué es Node.js?

Antes de entrar en materia y aprender Node.js deberíamos saber como hemos llegado hasta aquí, conocer un poquito la historia del desarrollo de aplicaciones web (tema en el que estoy especializado)

Tipicamente cuando desarrollabas una aplicación web dividías el trabajo en dos mundos. Por un lado tenías la parte Frontend y por otra la parte Backend. Normalmente se empezaba a trabajar primero en el Backend con lenguajes típicos de Backend como PHP, ASP o Java.

Ahí definías tus modelos de datos, tus controladores, servicios y básicamente la lógica de tu aplicación.

Por otro lado y de forma paralela había que ir construyendo la parte Frontend con lenguajes típicos como HTML, CSS y Javascript.

Ahí definías la parte visual, la estructura y la lógica de cara al cliente de tu aplicación/página web.

Esta dicotomía en el desarrollo de una aplicación/página web hizo que a medida que avanzaba la tecnología el mercado y los puestos de trabajo se dividieran en estas dos vertientes.

O te peleabas con la parte visual de la página o te peleabas con las tripas de la aplicación y por lo general el que trabajaba en el back no se entrometía en el front y viceversa. Esto generó muchos puestos de trabajo y muchos profesionales especializados en su “parte”.

Pero y aquí es cuando la matan, llegó un día en el que se “estandarizó” un lenguaje de programación para unir estos dos mundos tan diferentes.

Una herramienta que te permitía con el mismo lenguaje de programación trabajar en la parte Frontend y en la parte Backend. Hablo de Javascript y de Node.js.

Pero para entender qué es Node.js vamos a ver su definición formal de la Wikipedia:

Node.js es un entorno en tiempo de ejecución multiplataforma, de código abierto, para la capa del servidor (pero no limitándose a ello) basado en el lenguaje de programación ECMAScript, asíncrono, con I/O de datos en una arquitectura orientada a eventos y basado en el motor V8 de Google

Esto quiere decir que con Node.js vamos a tener la misma o parecida capacidad de desarrollo que tienen otros lenguajes de programación del lado del servidor pero trabajando con Javascript.

Suena fantástico para todos aquellos Frontend que quieren dar el salto a las aplicaciones de servidor ya que no van a necesitar aprender un lenguaje nuevo sino que se pueden adaptar a Node.js con su experiencia previa y con una de aprendizaje bastante baja.

¿Pero qué ventajas tiene aprender Node.js como para plantearme hacer el cambio?

Pues bueno, uno de sus puntos fuertes es la concurrencia. A diferencia de PHP o Java en el que cada petición genera un hilo de ejecución, con Node.js te tienes que despreocupar de eso ya que funciona de forma asíncrona con un único hilo de ejecución orientado a eventos.

Cuando llega una petición esta se pasa a un pool de eventos. Este pool va consumiendo las peticiones sin bloquear la I/O mientras que el script que lanzó la petición sigue trabajando.

Solo cuando el pool ha terminado de procesar la petición envía un evento que es capturado por el script original y ordena que se ejecute algo definido en la función de callback.

Si quieres profundizar en el funcionamiento interno de Node.js este enlace (ojo, en inglés) te ayudará a entender como funciona toda esta película 😉

http://www.journaldev.com/7462/node-js-architecture-single-threaded-event-loop

Algo que en mis años como programador Symfony siempre me ha encantado es el sistema de bundles que existe.

Un bundle no deja de ser un paquete de código atómico y reutilizable que solventa un problema y que cualquiera puede instalar en su proyecto sin necesidad de reinventar la rueda.

Como no podía ser de otra forma Node.js también tiene algo parecido y son los módulos.

Existen módulos básicos para el manejo de ficheros, de protocolos de red, de Timers, de Streams… pero también existen otros módulos desarrollados por la comunidad y que puedes usar en tu proyecto sin ningún tipo de problemas.

En este enlace puedes ver un listado de módulos típicos y útiles en una aplicación Node.js

https://www.codementor.io/ashish1dev/list-of-useful-nodejs-modules-du107mcv3

Estas dos características y la potencia que tiene el escribir en el mismo lenguaje todas las partes de tu página/aplicación web deberían ser suficientes como para que te plantees el aprender Node.js pero por si todavía tienes dudas aquí puedes ver una comparación de rendimiento entre una aplicación Java y otra construida con Node.js.

Cómo instalar Node.js

Instalar Node.js es muy sencillo, ya estés utilizando Windows, Linux o Mac OS lo único que tienes que hacer es dirigirte a su página de descargas y seleccionar el paquete que te interesa.

Una vez entres en este enlace podrás decidir si descargarte una versión LTS de largo soporte o la última versión liberada. Si vas a utilizar Node.js para producción te recomiendo que te descargues la versión LTS.

Su instalación es muy sencilla, te aparecerá un asistente y realmente tendrás que ir haciendo click en el botón de siguiente (a no ser que quieras configurar algo mas avanzado como el directorio de instalación…)

Junto con Node.js se te va a instalar también NPM que es el gestor de paquetes que utilizamos para manejar las posibles dependencias que tendrá nuestro proyecto.

Cuando haya terminado la instalación podemos comprobar la versión tanto de Node.js como de NPM con los siguientes comandos:

$ node -v 
v7.9.0

$ npm -v
4.2.0 

Si por un casual ha salido una versión nueva de NPM y queremos actualizarnos tenemos estos dos comandos:

$ npm install -g npm
$ npm update -g npm

El flag -g es para instalar/actualizar a nivel global.

Hasta aquí la parte mas sencilla de empezar a aprender Node.js 🙂

Primer script de consola en Node.js

En el camino al zen de aprender Node.js estamos en el primer nivel. Ya hemos configurado todo lo necesario para poder correr aplicaciones hechas con este entorno de desarrollo y lo que vamos a hacer a continuación es crear una pequeña aplicación de prueba.

Al ser Node.js un entorno para programar aplicaciones javascript del lado del servidor parece razonable que todos nuestros scripts sean scripts JS, ¿no?

Personalmente me encantan las aplicaciones de consola, ya sean desde procesos en bash y/o C, C++, los potentes comandos de Symfony o los scripts en Javascript. No hay límite, se puede construir lo que uno quiera pero para este ejemplo vamos a escribir una calculadora sencilla que acepta tres parámetros de entrada.

En el directorio en el que se encuentre nuestro workspace vamos a crear el siguiente fichero:

Vamos a explicar las líneas mas significantes del script:

  1. La primera línea, la declaración del ‘use strict’, sirve para indicar a los navegadores que en el momento de interpretar el código sean mas “estrictos” a la hora de permitir ciertas licencias al programador como por ejemplo el uso obligatorio en la declaración de variables o la captura de errores y excepciones. En definitiva, hacer que tu código sea mejor. Para mas información échale un vistazo a este enlace.
  2. Con la siguiente línea estamos capturando los argumentos pasados en la ejecución del script. Para ello invocamos al método process.argv.slice(2) y lo guardamos en una variable que será un array. El porqué del número 2 dentro de la función slice tiene significado. Piensa en arrays, cuando ejecutemos el script en la terminal, el primer nodo del array estará reservado para el interprete (node), el segundo nodo del array será para el script (calc.js) y el tercer nodo para los argumentos a pasar al script.
  3. El resto de líneas creo que no hace falta explicarlas, javascript y programación básica, asignaciones, casting de datos y sentencias de control. Primero de programación oye!

Para ejecutar este primer script tendremos que hacerlo de la siguiente forma:

$ node calc.js 1 + 4

Decir que los parámetros se tienen que pasar separados, es decir, primer parámetro un número, segundo parámetro un operador y tercer parámetro otro número.

Ah! y son recibidos como strings así que acuérdate siempre de hacer la conversión de tipos (si es que tu script lo necesita)

Hala a jugar! 😛

¿Qué es y cómo instalar Express en Node.js?

Otro tema interesante y necesario en el proceso de aprender Node.js es el uso de Express. ¿Pero qué es Express me preguntaréis…?

Bueno pues Express es una infraestructura para aplicaciones hechas en Node.js que nos provee un conjunto de utilidades como el enrutado de la aplicación, el uso del protocolo HTTP y la capacidad de crear APIs Restful entre otras cosas. A día de hoy no concibo una aplicación node sin express.

Para instalar Express en nuestro proyecto tendremos que echar mano de la terminal y del gestor de dependencias NPM, para ello escribimos lo siguiente:

$ npm install express --save

Y ya está, una vez terminé la instalación ya podremos utilizar Express en nuestro proyecto.

El flag –save indica a NPM que guarde una copia del paquete a instalar dentro del directorio del proyecto y que lo añada a la lista de dependencias. Util cuando le pasamos el proyecto a un nuevo miembro del equipo de desarrollo y tal…

Desde este enlace puedes consultar todas las referencias que nos provee este framework de desarrollo.

¿Qué es y cómo instalar BodyParser?

Es un middleware (es una capa que se ejecuta antes de nuestro código) que nos va a permitir manejar y parsear en objetos JSON las request que hagamos a nuestra aplicación.

Pero no solo va a convertir a objeto JSON la request sino que podemos configurarlo para que haga un parseo a RAW, a texto plano o a lo que en inglés se conoce como “URL-encoded form body” (vale, no se el equivalente en castellano xD)

En su repositorio de github tienes un montonazo de información útil, te recomiendo que le eches un vistazo y que lo utilices en tus proyectos si o si.

Para instalarlo hay que utilizar el gestor de dependencias NPM tal que así:

$ npm install body-parser

Y ya está!

¿Qué es y cómo instalar Nodemon?

¿Sigues queriendo aprender Node.js? Pues una de las utilidades que vas a necesitar en tu camino al zen es Nodemon. ¿Y qué es me preguntarás?

Pues Nodemon es un demonio (o un daemon tal y como se conoce en informática a este tipo de programas) que te permite recargar toda tu aplicación web al detectar un cambio en tus ficheros sin necesidad de tener que parar a mano el servidor y volver a levantarlo. Lo hace automáticamente!

Es muy sencillo de instalar como de utilizar, para ello tecleamos los siguiente en la terminal:

npm install -g nodemon

Cuando acabe la instalación y para añadirlo a nuestro proyecto podemos configurar la sección de scripts de nuestro package.json.

Esta sección nos permite definir nuestros propios comandos dentro de la aplicación. Me explico: si por ejemplo tenemos una suite de test unitarios que se ejecutan y generan un report de cobertura mediante tres comandos diferentes (por ejemplo) desde esta sección podríamos definir un “alias” para toda la secuencia de comandos y así lanzando uno solo se ejecutaría todos.

Pero vamos a ver el ejemplo de como añadir Nodemon para que se levante cada vez que arrancamos el servidor de nuestro proyecto:

"scripts": {
 "start": "nodemon index.js",
 "test": "echo "Error: no test specified" && exit 1"
 },

El primer comando que hemos definido es el start indicándole a nodemon que mire el entrypoint index.js y así pues cuando lancemos un npm start sobre la raíz de nuestro proyecto se levantará de manera automática este demonio 😉

Crear un servidor con Node.js

Ahora si que si. Ya estamos preparados para aprender Node.js de verdad. Hasta este punto hemos estado instalando lo básico para comenzar a trabajar pero a partir de aquí ya si que vamos a bajar al barro y vamos a codificar nuestra primera aplicación 🙂

Y lo primero que tenemos que hacer es lanzar el comando npm init para que se nos genere el fichero package.json. Este fichero es el que contiene el manifiesto de nuestra aplicación, algo así como un resumen. Aquí se define desde el autor, la versión, la licencia de la aplicación, las dependencias tanto de desarrollo como de producción entre otras cosas.

Uno de los puntos que nos va a preguntar la consola cuando lancemos el comando npm init es por el entrypoint, es decir, el punto de entrada que ejecutará el servidor web. Por defecto nos lo deja en index.js dentro de la raíz del proyecto pero si por cambios organizativos en el directorio de la aplicación este punto de entrada se encuentra en otro lugar podemos indicárselo perfectamente.

Se me ha olvidado decir que con Node.js no necesitamos instalar un Apache o un Tomcat como hacíamos con PHP o Java si no que ya nos ofrece métodos para crear y levantar un servidor web escribiéndolo con Javascript.

Mira el script anterior, es un ejemplo muy sencillo de servidor hecho con Node.js y la definición de una ruta GET. Pero vamos a explicarlo poco a poco.

  1. La primera línea es la declaración del modo estricto tal y como hemos comentado antes.
  2. La segunda línea es la inclusión de Express en el script. A partir de ahora podremos utilizarlo en toda la aplicación.
  3. Siguientes líneas vamos a obviarlas de momento.
  4. En la línea 13 del script definimos una ruta en la raíz principal. Esta ruta aceptará peticiones GET. Lo primero que hay que indicar es la URI de la ruta y después una función de callback a la que le pasamos los objetos request y response.
  5. En la línea 20 levantamos el servidor y hacemos que escuche por el puerto definido en su primer argumento. El segundo argumento es para la función callback que podemos utilizar para imprimir por consola el estado del servidor (o hacer otras cosas interesantes!)

Ahora si todo ha ido bien y nos dirigimos a http://localhost:3000 deberíamos ver lo siguiente.

Eso significa que tanto la instalación de Node.js como sus dependencias y que el proyecto están funcionando correctamente.

A partir de aquí nos queda ir aprendiendo el resto de componentes de esta tecnología pero será poco a poco en otros artículos

Si tienes algún tipo de preguntas o tan solo quieres ponerme a parir no dudes en hacerme llegar tus comentarios a través del siguiente banner de Twitter.

[xyz-ips snippet=”FAQS-GORKAMU-TW-YELLOW”]

Hala a cascarla!

Conceptos básicos de la programación orientada a objetos

En pleno siglo XXI y con una tendencia cada vez mas en aumento del dominio digital en nuestras vidas es imprescindible que todos tengamos unos conocimientos mínimos sobre informática, tecnología y programación. A lo largo de mi vida he conocido a muchas personas que solo sabían encender el ordenador y acceder a sus redes sociales, compartir sus fotos en Instragram y descargar películas desde plataformas de sharing.

Y tal vez eso sea suficiente para ellos pero si ahora mismo desarrollas un trabajo delante de un ordenador deberías tener unos conocimientos técnicos mínimos; y no hablo de conocer el sistema de señales del kernel de nuestro ordenador o saber como gestionar la memoria de tu máquina, tan solo quiero remarcar la importancia de poseer unos conocimientos técnicos en un mundo en el que cada vez dependemos mas de la informática.

Ya se ha demostrado la sana relación que existe entre los niños y la programación en su proceso de aprendizaje maduro. Esto tiene muchísimas ventajas en la formación del cerebro y en su definición de la personalidad. Un niño que aprende programación esta sin saberlo amueblando su cabeza y recibiendo herramientas para pensar de una manera lógica y desarrollando su capacidad para resolver problemas.

Entonces, si un niño es capaz de aprender un lenguaje de programación ¿porque tu no vas a poder aprenderlo?

Otra cosa es si de verdad quieres desarrollar su autosuficiencia tecnológica o si por el contrario quieres seguir dependiendo del friki gordo que juega con los ordenadores toda tu vida. Cuando ese tío ya no este, ¿qué vas a hacer cuando aparezca la temida Blue Screen Of Death en tu ordenador y tu trabajo tenga que ser interrumpido? Por ejemplo…

Por eso y como modo de educación os voy a contar los conceptos de la programación para que a los que os interesa sigáis aprendiendo y para los que no os interesa tanto por lo menos que conozcáis en qué se basa nuestro trabajo y desmentir el mito de que los programadores apretamos un botón y el trabajo ya está hecho.

Por cierto, no somos vagos. Trabajamos con la ley del mínimo esfuerzo pero siempre buscando la manera de optimizar y automatizar procesos de trabajo. 😛

programador

¿Qué es la programación orientada a objetos?

Dentro de la programación existen diferentes paradigmas sobre como afrontar y resolver un problema y estos tipos de paradigma están ligados al desarrollo histórico de la tecnología y de nuestra capacidad para producir mejores máquinas y aumentar la capacidad de cálculo y procesamiento de estas.

Si hacemos una búsqueda rápida veremos que podemos desarrollar haciendo programación funcional, programación imperativa, programación estructural, programación orientada a objetos o las recientes en alcanzar hype programación orientada a eventos y orientada a comportamientos, entre muchas otras…

Pero en este caso vamos a aprender qué es la programación orientada a objetos y para ello la wikipedia nos dice lo siguiente:

La programación orientada a objetos (POO, u OOP según sus siglas en inglés) es un paradigma de programación que viene a innovar la forma de obtener resultados. Los objetos manipulan los datos de entrada para la obtención de datos de salida específicos, donde cada objeto ofrece una funcionalidad especial.

Tal vez esta definición te deje con el culo torcido. Para aclarar las dudas y asentar las bases de la programación orientada a objetos has de saber que nuestros ordenadores contienen y procesan datos. Estos datos no dejan de ser información plana que carece de sentido por si mismos y que solo al ser analizados en un universo determinado y conocido obtienen el significado que nos es necesario para nuestros requisitos.

Me explico. Imagina que nuestro ordenador posee los siguientes datos:

Altura Anchura
50 20

Vale, vemos en la tabla que tenemos un dato que representa la altura, cuyo valor es 50, y tenemos otro dato que representa la anchura, que vale 20.

Pero ¿a qué representan estos valores? ¿Son las medidas de una persona? ¿Las medidas de una caja tal vez? ¿O las propiedades de un paquete de tabaco en un dibujo? Digo en un dibujo porque es un plano bidimensional tal y como lo son la altura y la anchura. Al no haber valor para la profundidad, plano Z, no podemos representar una caja o una persona de tres dimensiones, solo es un ejemplo educativo, no os pongáis tiquismiquis cabrones…

Pues bien, esa caja, esa persona o ese paquete de tabaco es a lo que me refiero con el universo concreto de los datos, es el contexto que le da sentido a los valores numéricos que hemos visto. Y como los datos y la informática es impersonal y carente de significado, la programación orientada a objetos es la herramienta que utilizamos para traducir esos valores a conceptos que conocemos de nuestra vida real.

La programación orientada a objetos como su nombre indica trabaja con objetos y nuestro paquete de tabaco del ejemplo es un objeto. Este objeto tiene propiedades como la altura y la anchura y encima puede realizar acciones por si mismo y puede ser sometido a acciones, como por ejemplo abrir el paquete, sacar un cigarrillo, comprobar que tenga tabaco o que el cartón del paquete se degrade.

Pues en la programación orientada a objetos, todo este conjunto de propiedades y acciones es lo que se conoce como objeto que es la representación abstracta de un objeto real de la vida real. ¿Se entiende?

Bueno, si todavía no te ha explotado la cabeza tomate un descanso, tomate un café o échate un piti porque vamos a entrar en faena a partir de aquí…

Representando los datos mediante las clases

Ya hemos visto cual es la definición de un objeto dentro de la programación orientada a objetos, pues bien una clase es la plantilla que vamos a utilizar para modelar este conjunto de datos o estos objetos vamos. Utilizamos las clases para representar entidades o conceptos y definen un conjunto de variables (propiedades) y de métodos (acciones).

Tal y como hemos visto, las clases y objetos suponen el pilar fundamental de la programación orientada a objetos.

Cuando estamos programando y utilizamos una clase, osea la plantilla, para crear un objeto digital, decimos que estamos instanciando una clase.

Para que nuestro ordenador nos entienda tenemos que escribir una clase tal que así:

Atención:

Tutorial basado en PHP. Si eres un Javero o defensor aferrimo de otros lenguajes y te entran pampurrias por favor vete 😛
Cada lenguaje utiliza diferentes sintaxis aunque compartan ciertos aspectos en común.

https://gist.github.com/gorkamu/48c0c5a623b69cb18cc1ac4f086aba30.js

Vale, tal y como puedes ver en el ejemplo, hemos definido la clase utilizando la palabra reservada class para a continuación nombrar a esta clase con el nombre PaqueteDeTabaco. El nombre de una clase puede ser cualquier nombre que te de la gana siempre y cuando no utilices una palabra reservada de esta lista.

Si te fijas bien, la clase tiene un conjunto de propiedades (altura y anchura) y de métodos (cualEsLaAltura, cualEsLaAnchura, abrirPaquete, comprobarSiHayTabaco, sacarCigarrillo)

Las propiedades tienen la palabra private delante de su definición y esto tiene que ver con las buenas prácticas en la programación orientada a objetos y con el encapsulamiento de datos. La palabra reservada private hace referencia al ámbito de las variables o como se diría en inglés al scope.

Existen varios tipos de ámbitos o de visibilidad de propiedades y métodos:

  • public: permite que el valor de la propiedad o el método sean accesibles desde cualquier lugar como por ejemplo otra clase u otras instancias de esa clase.
  • protected: hace que el valor de la propiedad o el método sea accesible desde la misma clase o desde cualquier otra que herede de ella.
  • private: hace que el valor de la propiedad o el método solamente sea accesible desde la misma clase que la define.

El valor de una propiedad no debería ser accesible desde fuera de una clase o desde otra clase sin utilizar un método que nos proporcione ese valor y aquí es donde entran los métodos getters y setters. Métodos get para recuperar un valor y métodos set para establecer un valor. Por ejemplo, si queremos acceder a la altura del paquete de tabaco tendríamos que hacerlo tal que así.

$paqueteDeTabaco->cualEsSuAltura();

Vuelve a fijarte en la definición de la clase que hay algo que todavía no he explicado… ¿Ya? ¿No te mosquea el uso de la palabra $this? ¿No sabes qué es?

Pues bien, la palabra $this es una pseudovariable, no forma parte de nuestra clase ni tenemos que definirla ni nada por el estilo, es una forma que nos da la sintaxis del lenguaje para poder acceder a elementos de una clase dentro de la misma clase ya sean propiedades o métodos y que solo funciona dentro de la clase.

Si intentas utilizar en cualquier lugar fuera de la clase te fallará.

Creando instancias de clases

Para crear la instancia de una clase y poder utilizarla en nuestro programa tendremos que utilizar la palabra reservada new.

$paqueteDeTabaco = new PaqueteDeTabaco();

Cualquier objeto se creará siempre y cuando tenga un constructor, pero ¿qué coño es un constructor?

Pues un constructor es el método que se encarga de construir el objeto, ¿obvio no? Un constructor se define tal que así:

function __construct() {
...
}

Al utilizar la palabra reservada new, internamente estamos llamando al constructor de la clase, aunque si te fijas en la clase del ejemplo, verás que no hay definido ningún constructor y esto es porque la clase utiliza el constructor por defecto, que al igual que con la pseudovariable $this no nos tenemos que preocupar de definir, ya nos lo provee el lenguaje.

Solo nos preocuparemos de definir siempre y cuando  queramos hacer algo específico en el proceso de construcción del objeto como por ejemplo inicializar variables o llamar a métodos de la clase.

Al igual que todo en la vida, todo lo que se crea se puede destruir y en la programación orientada a objetos no podría ser de otra forma. El lenguaje también nos provee de un método para destruir el objeto y esto es el destructor o la función destructora.

function __destruct() {
...
}

Generalmente utilizamos esta función para liberar memoria, aunque ese es un tema para otro post…

Otra cosa que podemos hacer con los objetos a parte de construirlos y destruirlos es clonarlos o lo que es lo mismo, hacer una copia de ellos mismos. Cuando se clona un objeto PHP hace una copia superficial de todas las propiedades del objeto. Si por cualquier caso una de estas propiedades es una referencia a otra variable el objeto clonado mantendrá esta misma referencia.

$paqueteDeMarlboro = new PaqueteDeTabaco();
$paqueteDeChester = clone $paqueteDeMarlboro;

Internamente al hacer una copia de un objeto estamos llamando al método mágico __clone().

Otro concepto importante en la programación orientada a objetos es la herencia.

Entendiendo la herencia

Entendiendo la herencia y digo entendiendo porque es un concepto bastante abstracto que tenemos que masticar muy detenidamente.

Volvamos al ejemplo del paquete de tabaco. Un paquete de tabaco es un concepto abstracto ya que nos imaginamos el concepto pero no somos capaces de identificar de que marca de tabaco se trata, si pertenece a tabaco negro o tabaco rubio o si se trata de cigarrillos hechos o de tabaco de liar.

Ahora si te imaginas un paquete de Ducados, otro de Marlboro y otro de Golden Virginia, estarás de acuerdo conmigo en que los tres son paquetes de tabaco y que entre ellos comparten ciertas características como la altura y la anchura del paquete pero se diferencian entre ellos del tipo de tabaco, de la presentación y de la marca.

Ademas estos tres paquetes pueden realizan acciones como abrir el paquete y/o saber cuantos cigarrillos quedan, sin embargo, por la fisionomía del packaging de los distintos paquetes, cada uno de ellos se pueden abrir de una forma diferente, por ejemplo…

Pues bien, si aplicamos esta lógica a la programación orientada a objetos, tendremos cuatro clases diferentes:

  • PaqueteDeTabaco.class.php
  • PaqueteDeDucados.class.php
  • PaqueteDeMarlboro.class.php
  • PaqueteDeGoldenVirginia.class.php

La clase PaqueteDeTabaco.class.php sería la clase padre y el resto de clases son las clases hijas que heredan de la clase padre. Mejor veamoslo con un dibujico…

Herencia en la programación orientada a objetos
Herencia en la programación orientada a objetos

Tal y como se ve en la imagen, cada una de las clases hijas comparten propiedades y métodos entre ellas gracias a la clase padre. Una instancia de la clase PaqueteDeDucados.class.php, otra de la clase PaqueteDeMarlboro.class.php y otra de PaqueteDeGoldenVirginia.class.php podrán utilizar el método abrirPaquete() y cualquiera de las tres podrán acceder al método cualEsLaAltura() para obtener el valor de la propiedad $altura de la clase padre y todo este gracias a la herencia.

Sin embargo, si preguntas al PaqueteDeDucados por su marca y tipo serán muy diferentes de las del PaqueteDeMarlboro.

$paqueteDeDucados->cualEsLaAltura();
$paqueteDeMarlboro->abrirPaquete();
$paqueteDeGoldenVirginia->comprobarSiHayTabaco();

Si nos ponemos puristas esto no sería del todo así ya que ambas clases hijas comparten marca y tipo de tabaco por lo que haciendo una buena refactorización deberíamos situar estas propiedades en la clase padre, pero para el ejemplo y para que sea mas visual nos vale.

Así pues, para que una clase herede de otra en PHP deberemos utilizar la palabra reservada extends en la definición de la clase.

Todos los métodos y propiedades de la clase padre pueden ser sobrescritos por las clases hijas. Esto quiere decir que, siguiendo el ejemplo, podemos re-definir el comportamiento de la función abrirPaquete() para una clase en concreto, por ejemplo para la clase del paquete de Golden Virginia ya que este tipo de tabaco no se vende en una cajetilla sino en un sobre y por lo que para abrir el paquete deberemos desenrollarlo en lugar de abrir la cajita, no se si me explico xD

Podremos sobrescribir un método padre siempre y cuando no haya sido definido como final.

Por otro lado, para acceder a una propiedad o llamar a un método padre desde una clase hija tenemos que utilizar la palabra reservada parent junto con el nombre del método.

https://gist.github.com/gorkamu/83780bea63001cf9c93ffc15a04ea721.js

Pues bien, como podemos ver en la clase de arriba, tenemos el método sacarCigarrillo() que pertenece a la clase padre pero que en este ejemplo de clase hija debemos re-definir ya que en el tabaco de liar los cigarros no vienen hechos sino que tenemos que coger un poco de tabaco, un papel y un filtro y liarlo.

A diferencia del resto de clases de paquetes de tabaco, el método sacarCigarrillo() nos devolvería un cigarro, sin tener que liarlo y por lo cual no haría falta sobrescribir este método.

 

Pues nada, obviamente quedan muchísimo mas conceptos por conocer y dominar en la programación orientada a objetos pero para ir entrando en faena creo que esta ha sido una buena primera aproximación.

Se que el tema ha sido largo y puede ser duro para una persona que nunca ha visto nada sobre lenguajes de programación así que si tienes algún tipo de duda o sugerencia puedes dejarme un comentario mas abajo o hacerlo a través de twitter a través del siguiente banner.

[xyz-ips snippet=”FAQS-GORKAMU-TW-YELLOW”]

¡Hala a mamarla!

Patrones de diseño I: dominando el patrón singleton

¿Que pasa muchachos? Con este post inicio una nueva serie de artículos que espero que lleguen a buen puerto. Esta serie de artículos va a tratar sobre algo muy importante en el desarrollo, los patrones de diseño. Conocerlos puede marcar la diferencia entre ser un pica códigos del montón a conseguir un buen puesto de trabajo como Senior Developer – Analista Programador. Además conocer los diferentes patrones de diseño te ayudará a desarrollar un código mejor, mas limpio y que coño, te hará sentir mejor profesional así que vamos con ello…

Dominando el patrón singleton

He decidido empezar por el patrón singleton porque es el mas básico que tienes que conocer. Personalmente no es el que mas me guste pero para avanzar en otros patrones de diseño mas complejos por aquí se puede ir adquiriendo una buena base.

El patrón singleton lo utilizamos cuando queremos tener una instancia única de una clase con un único punto de acceso global para todos los clientes que la requieran, en otras palabras, con el patrón singleton nos aseguramos que una clase solo instancia una vez.

¿Cuando nos interesa elegir este patrón? Pues cuando tenemos por ejemplo objetos que han de ser atómicos, por ejemplo la conexión con la base de datos o el email sender. Imagínate que por cada consulta a la base de datos tuviéramos que crear una nueva instancia y abrir la conexión, a la larga esto afectaría al rendimiento de la aplicación pudiendo llegar a llenar el heap del sistema.

Para aplicar el patrón singleton tenemos que tener un constructor privado en nuestra clase que solo sea accesible desde la misma clase, también necesitaremos una instancia privada de la clase y métodos estáticos que devuelvan la instancia.

<?php

 namespace PatronesSingletonDatabase;

 class Database 
 {
     private static $instance;
     private $db;

     private function __construct(){
         $this->db = new PDO("mysql:host=server;dbname=database", "user", "password");
     }

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

     public function __clone(){
         trigger_error('No puedes hacer eso hamijo', E_USER_ERROR);
     }
 }

?>

Como veis, en la clase Database, he definido una propiedad privada llamada $instance, esta es la variable que almacenará toda la clase cuando la instanciemos. Después está el constructor por defecto con un acceso privado, esto lo utilizamos para inicializar todo lo que necesitemos iniciarlizar, en el ejemplo, la cadena de conexión con la base de datos.

La función getInstance() se encarga de comprobar si ya existe una instancia definida, de ser así la devuelve, en caso contrario crea una nueva mediante el uso de la constante __CLASS__ que nos devuelve el nombre de la clase.

Por último el método mágico __clone() controla que no se puedan instanciar mas objetos de esta clase y así saltarse el patrón singleton por el arco del triunfo…

Para utilizarlo es tan sencillo como llamar al método estático getInstance() de la clase y ya nos devolverá una instancia totalmente funcional de la clase Database.

<?php

 require_once 'Database.class.php';

 $conexion = Database::getInstance();
 
?>

Con este primer artículo pretendía introducirte en el maravilloso mundo de los patrones de diseño y mas concretamente en el patrón singleton, en este enlace puedes aprender más sobre este patrón. Voy a colgar este ejemplo en mi github para que os lo podáis clonar y meterle mano a vuestro gusto.

 

Y permaneced atentos por que aún quedan muchos patrones por explicar como el Modelo Vista Controlador, el Adapter, el Data Access Object, el Factory… en fin…

¡Hala a cascarla!