En el anterior capítulo nos quedamos con el servidor Node montado y corriendo. Lo próximo es construir una aplicación más compleja que responda a varias URLs, para ver en movimiento algo de lo que sería REST. Evidentemente, debemos examinar la petición HTTP, extrayendo de ella la URL pedida y, ocasionalmente, sus parámetros GET/POST.
La idea es que para procesar las peticiones necesitamos una especie de router que, dependiendo de la URL, mapee a los distintos manejadores, y en un rato veremos el cómo. En este punto hace falta aclarar un pequeño detalle:
Si comparamos Node con, por ejemplo, un Apache+PHP, hay una diferencia principal: el código PHP contiene la lógica, accesos a base de datos, etc.; es decir, implementa la aplicación, pero es Apache quien se encarga de servirla y gestionar las peticiones. Node realiza las funciones de ambos, no sólo implementamos la aplicación sino también todo el servidor, de forma que la aplicación web y su servidor web son esencialmente lo mismo.
Callbacks y funciones anónimas
Bien, ya vimos la función principal en nuestro hello.js, que crea el servidor y escucha peticiones en el puerto indicado. Al crear el servidor le estamos pasando una función como parámetro, lo cual se puede hacer en JavaScript incluso sin crear anteriormente la función. Es decir, se puede asignar una función a una variable y después pasar esta como parámetro, o bien definir la función en el mismo parámetro y por tanto no hay que darle un nombre (función anónima).
Este tipo de comportamiento se debe a la naturaleza de Node.js y a que trabaja orientado al evento. De esta forma, pasando una función al método que crea el servidor, cada vez que se reciba una petición, esta función será llamada (callback). Así que manipulamos ahí mismo la petición entrante, justo donde se captura el evento.
La estructura de la URL
Por otra parte, a la función que responde al evento (manejador) se le pasan dos objetos, request y response, con cuyas propiedades podemos obtener los detalles de la petición y procesarla adecuadamente.
Repasemos por un momento la estructura de las URLs y las partes que nos pueden interesar. En esencia, una URL puede tener unas cuantas de estas cosas (algunas de ellas están siempre, aunque no las veamos en el navegador, como las meigas):
Brevemente:
- Protocolo: normalmente HTTP, pero también HTTPS, FTP, etc.
- Host/Hostname: dominio, es decir, nombre o dirección IP de la máquina.
- Puerto: puerto de red en el que escucha (por defecto 80 en HTTP).
- Path: ruta en la que se localiza el recurso.
- Query: parámetros de la petición: pares de variable=valor.
Obviamente, las partes importantes aquí son el path y la query: queremos saber a qué recurso se ha accedido, y si vienen datos con ello. Los obtenemos de la siguiente manera (usando los módulos internos url y querystring):
var url = require(‘url’);
var querystring = require(‘querystring’);
// Obtener el path o la query como cadena
var path = url.parse(request.url).pathname; // “/hola”
var query = url.parse(request.url).query; // “nombre=Pepito&apellido=Pérez”
// Obtener el objeto JSON a partir de la cadena query
var params = querystring.parse(query); // { nombre: Pepito, apellido: Pérez }
A través del objeto request también podemos obtener otras cosas interesantes, como protocolo y versión, método, cabeceras…
Módulos: require y exports
Para dotar a nuestra aplicación de cierta organización, podemos separar todo el código en módulos. Esencialmente, un módulo es un fichero que agrupa ciertas funcionalidades, y que se puede usar posteriormente desde otro fichero.
Vemos en los ejemplos algunas líneas con require. Dado que ‘http’, ‘url’ o ‘querystring’ son módulos (internos de Node.js en este caso), require carga las funcionalidades que dichos módulos proporcionan (exportan).
Ahora nos queda crear nuestros propios módulos, y despues utilizarlos. Dentro de un módulo, podemos elegir qué partes queremos exportar, ya que todo lo que haya dentro es por defecto privado (variables, funciones, clases…). Y de hecho, la palabra que se usa para ello es exports.
Lo explican genial aquí, por lo que me limito a decir que lo haríamos de una de las dos formas:
a) Exportando los componentes por separado:
var num = 35;
var sumar = function(a, b) {
return a+b;
}
module.exports.num = num;
module.exports.sumar = sumar;
--------------------------------
var utils = require(‘./modulo);
var x = utils.num + 2;
var res = utils.sumar (4,9);
b) Exportando todo en una función:
var miClase = function(param1, param2) {
this.param1 = param1;
this.param2 = param2;
}
module.exports = miClase;
--------------------------------
var clase = require(‘./miClase’);
var obj = new clase();
// O también:
var obj = new require(‘./miClase’)();
Mezclar y agitar
Muy bien, ya tenemos todos los ingredientes: callbacks y funciones anónimas, partes interesantes de la URL y nuestros propios módulos.
Ya podemos hacernos nuestro router casero, y poder decirle hola y adiós al usuario (un ejemplo muy básico para entender cómo se mapean las peticiones).
Para que no haya confusión, voy a renombrar mi hello.js a app.js (nombre más coherente), y voy a crear también router.js, que será usado en la aplicación principal.
function route(pathname, query) {
switch (pathname) {
case "/hola":
return "Hello " + query["nombre"] + " " + query["apellido"]
case "/adios":
return "Bye bye " + query["nombre"] + " " + query["apellido"]
default:
return "Este recurso no existe!"
}
}
exports.route = route;
var http = require('http');
var url = require('url');
var querystring = require('querystring');
var router = require('./router');
http.createServer(function (request, response) {
res.writeHead(200, {"Content-Type'": "text/html"});
var pathname = url.parse(req.url).pathname;
var query = url.parse(req.url).query;
var params = querystring.parse(query);
var response = router.route(pathname, params);
res.write(response);
res.end();
}).listen(5555);
Claro que se podría hacer algo más elaborado, como tener en cuenta el método (GET/POST) y hacer cosas diferentes con uno y otro, pasarle al router también el objeto response y devolver una página 404 para los recursos que no existan, o bien cambiar el switch y organizar los recursos pedidos de otra manera…
Para todo esto existe una librería que veremos el próximo día: Expressjs 🙂
Saludos!
Bonus4Code 