Node.js es una librería y entorno de ejecución de E/S dirigida por eventos y por lo tanto asíncrona que se ejecuta sobre el intérprete de JavaScript creado por Google V8. Lo cierto es que está muy de moda aunque no es algo nuevo puesto que existen librerías como Twisted que hacen exactamente lo mismo pero si es cierto que es la primera basada en JavaScript y parece que tiene un gran rendimiento o eso dicen los benchmarks.
No es la primera vez ni mucho menos que hablamos sobre programación dirigida por eventos y sobre frameworks de programación asíncrona y espero que tampoco sea la última. Lo que si es cierto es que es la primera vez que hablamos de este tema utilizando para ello un lenguaje que siempre ha estado enfocado al desarrollo del frontend y no del backend como ocurre en Node.js
En esta introducción a la programación asíncrona con Node.js, vamos a crear un servidor HTTPS básico que responda a algunas de nuestras peticiones de manera predefinida.
Estructuración del código
Node.js te permite implementar al patrón de diseño MVC a través de varios archivos o módulos donde alojar el código de nuestras aplicaciones y de esta forma no tener que escribir todo el código en un solo archivo JavaScript. Para nuestros ejemplos vamos a escribir un archivo principal llamado app.js que usaremos para iniciar nuestra aplicación y la lógica la programaremos en los módulos.
El servicio Web
Node.js integra un completo servidor (y cliente) web en el módulo http. Para hacer uso de un módulo en Node.js hemos de utilizar el comando require con un único parámetro, el nombre del módulo que queremos cargar:
/* Iniciamos el módulo http /
var http = require("http");
/ Creamos el objeto del servidor /
http.createServer(function(request, response) {
/ Preparamos las cabeceras de respuesta */
response.writeHead(200, {"Content-Type": "text/html"});
response.write("¿Que pasa tronco?");
response.end();
}).listen(4444);node server.js. Si apuntamos nuestro navegador a http://localhost:4444 nos encontraremos con nuestro mensaje.
En el ejemplo anterior hemos creado un servidor con el mítico ejemplo Hello World! adaptado al Genbetiano. Vamos a ver como funciona.
El método createServer del objeto http devuelve un objeto de tipo servidor al que le concatenamos directamente la llamada a su método listen y lo ponemos a escuchar en el puerto 4444 porque somos unos cuatreros.
Al método se le pasa un único parámetro que es una función anónima (que también podríamos haber definido previamente y pasarla como argumento, el resultado sería el mismo). Cada vez que el servidor recibe una nueva petición, Node.js llama a la función que le hemos pasado como parámetro, a este tipo de funciones se les llama callbacks.
A dicho callback se le pasan dos parámetros, request y response. Sus nombres son autodescriptivos, el primero de ellos es un objeto que contiene todos los datos relacionados con la petición y el segundo objeto es utilizado para responder al navegador. Cuando hemos acabado de responder al navegador tenemos que ejecutar response.end().
Ahora que hemos visto como crear un sencillo servicio web, vamos a refactorizar el código de server.js para convertirlo en un módulo de Node.js. No voy a hablar ni a poner ejemplos sobre TDD pero te recomiendo que le eches un vistazo a los módulos de terceros para TDD/BDD compatibles con Node.js
>var http = require("http");
function serverStart() {
http.createServer(function(request, response) {
response.writeHead(200, {"Content-Type": "text/html"});
response.write("¿Que pasa tronco?");
response.end();
}).listen(4444);
console.log("Server started...");
}
exports.start = serverStart;var server = require("./server");
server.start();node App,js, veremos el mensaje Server started... en la consola y si recargamos el navegador veremos que nuestra aplicación web cuatrera sigue funcionando.Routing
Ahora debemos atender a diferentes peticiones, para hacerlo, haremos uso del routing o enrutado de peticiones. Los que tengáis experiencia con otros frameworks como Twisted, Django o Rails (por ejemplo) os resultará muy familiar. Toda la información requerida está contenida en el objeto request que se le pasa a la función anónima al crear nuestro servidor.
Para poder procesar esa información con el objetivo de crear rutas para las peticiones HTTP hemos de hacer uso del módulo url. Vamos a crear un nuevo módulo llamado router.js donde escribiremos el código necesario para empezar a enrutar y a modificar el código de nuestro servidor.
var http = require("http");
var url = require("url");
function serverStart(route) {
http.createServer(function(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Received petition for " + pathname);
route(pathname);
response.writeHead(200, {"Content-Type": "text/html"});
response.write("¿Que pasa tronco?");
response.end();
}).listen(4444);
console.log("Server started...");
}
exports.start = serverStart;function route(pathname) {
console.log("Routing a new petition for " + pathname);
}
exports.route = route;var server = require("./server");
var router = require("./router");
server.start(router.route);$ node App.js
Server started...
Received petition for /
Routing a new petition for /
Received petition for /favicon.ico
Routing a new petition for /favicon.icoManejadores
Como ya hemos hablado en anteriores oportunidades, cada petición debe tener asociado un manejador de eventos que se haga cargo de procesar la petición. Así es como podemos modelar la lógica de negocio de nuestra aplicación. Vamos a crear un nuevo módulo al que llamaremos requestHandlers.js y que va a contener el código a ejecutar por cada evento. Esta forma de estructurar el código de la aplicación no es el más adecuado, pero lo hago así para mantenerlo simple para nuestros ejemplos. Asegúrate de usar siempre un patrón MVC para ordenar tu código.
function a_donde_vas(response) {
console.log("Handler for request 'a_donde_vas' dispatched.");
response.writeHead(200, {"Content-Type": "text/html"});
response.write("Patatas traigo");
response.end();
}
function disimula_disimula(response) {
console.log("Handler for request 'disimula_disimula' dispatched.");
response.writeHead(200, {"Content-Type": "text/html"});
response.write("Y la mula dijo si");
response.end();
}
exports.a_donde_vas = a_donde_vas;
exports.disimula_disimula = disimula_disimula;Ahora necesitamos refactorizar nuestro código en server.js y router.js para adaptarlo a nuestros manejadores.
var http = require("http");
var url = require("url");
function serverStart(route, handler) {
http.createServer(function(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Received petition for " + pathname);
route(handler, pathname, response);
response.writeHead(200, {"Content-Type": "text/html"});
response.write("¿Que pasa tronco?");
response.end();
}).listen(4444);
console.log("Server started...");
}
exports.start = serverStart;function route(handler, pathname, response) {
console.log("Routing a new petition for" + pathname);
if (typeof handler[pathname] === 'function') {
handler[pathname](response);
} else {
console.log("No request handler for " + pathname + " skipping");
response.writeHead(404, {"Content-Type": "text/html"});
response.write("404 Not Found");
response.end();
}
}
exports.route = route;Tan solo nos queda hacer unas modificaciones en App.js para despachar las peticiones. También añadimos el parámetro handler a la función start
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");
var handler = {}
handler["/"] = requestHandlers.a_donde_vas;
handler["/a_donde_vas"] = requestHandlers.a_donde_vas;
handler["/disimula_disimula"] = requestHandlers.disimula_disimula;
server.start(router.route, handler);Conclusión
Hemos hecho una breve introducción a la programación asíncrona con Node.js para ir abriendo boca, en la segunda parte de este artículo hablare sobre como manejar peticiones POST y como hacer algo realmente útil.
Más en Genbeta Dev | Introducción a la programación dirigida por eventos, Introducción a la programación asíncrona con Twisted