Node.js e le richieste HTTP (GET e POST)

Finora abbiamo visto come rispondere in maniera corretta alle richieste degli utenti, fornendo delle pagine HTML per esempio, ma perché un utente o un'altra applicazione possano interagire con la nostra, per inviare dati o indicare particolari comportamenti, possiamo sfruttare i parametri delle richieste HTTP. Vediamo quindi come gestire le chiamate di tipo GET o POST.

Come risulterà arcinoto, GET e POST sono due metodi del protocollo HTTP e la differenza principale tra i due sta essenzialmente nel meccanismo in cui vengono gestiti i parametri:

• con GET i parametri sono aggiunti all'URL della pagina, questo consente ad esempio di memorizzare nel bookmark una richiesta, come se fosse una pagina statica, oppure di associarla a un link (in questo si può dire che parametri rappresentano richieste comportamenti. ndR)
• POST è pensato invece per l'invio dei dati, che vengono aggregati nel corpo della chiamata e non rappresentati nell'url, in pratica risultano invisibili, non facilmente replicabili e senza limite al numero di caratteri

Il classico esempio di richiesta GET è quello che viene utilizzato per richiamare un articolo su un CMS fornendone l'ID.

Usare i dati delle richieste HTTP con Node.js

Nonostante la dimensione non banale delle API offerte dal motore di NodeJS, non esiste nessun meccanismo particolare per accedere ai parametri delle richieste HTTP. Per questo motivo è delegata allo sviluppatore l'intera gestione dei parametri a partire dall'identificazione del metodo utilizzato proprio perchè rappresenta un aspetto importante.

Per quanto riguarda GET non ci sono particolari criticità. Possiamo utilizzare il modulo url per analizzare l'url della richiesta ed estrapolare (oltre ai dati obbligatori come ad esempio protocollo e domino) i parametri inviati. Guardiamo un esempio:

var url_parts = require('url').parse(req.url, true);
console.log(url_parts.query); //stamperà una mappa chiave/valore dei parametri

Se spostiamo l'attenzione a POST tutto si complica dato che con questo metodo i parametri sono ufficiosamente "nascosti". Per poter accedere al corpo della richiesta dobbiamo sfruttare due eventi esposti dall'oggetto http.ServerRequest:

• data, che viene generato più volte, ad ogni chunk di dati ricevuto
• end, che è scatenato solo una volta, al completamento della ricezione

Guardiamo un esempio:

var body = '';
req.on('data', function(data) {
  body += data;
});
req.on('end', function() {
  var post = require('querystring').parse(body);
  console.log(post);
});

Per prima cosa definiamo una variabile stringa vuota, che sarà mano a mano popolata grazie alla callback agganciata all'evento data. Allo scatenarsi di end invece parsiamo il corpo della richiessta grazie al modulo querystring per ottenere, come per il metodo precedente, una mappa chiave/valore dei parametri.

Un aspetto molto comodo è la possibilità di mandare diversi parametri con lo stesso nome: in questo caso il nostro valore della mappa non sarà un elemento scalare, ma un vettore di valori. Molto comodo in caso di parametri multipli per i quali non si conosce a priori il numero di elementi.

Aggiungere le funzioni al nostro piccolo server Web

Una volta identificato come poter estrapolare i parametri non resta che rendere questa funzionalità più accessibile. Riprendiamo quindi in mano la nostra libreria httpdispatcher sviluppata nelle lezioni recedenti e aggiungiamo questo comportamento in modo da poter avere questi parametri a disposizione nei nostri listener.

Nell'esempio seguente aggiungeremo all'interno del metodo dispatch, poco prima di invocare il listener, una funzionalità che sulla base del metodo invocato aggiungerà un nuovo attributo all'oggetto request permettendo quindi di accedere ai parametri HTTP anche ad un livello più alto.

HttpDispatcher.prototype.dispatch = function(req, res) {
  var parsedUrl = require('url').parse(req.url, true);
  if(parsedUrl.pathname.indexOf(this.staticFolderPrefix) == 0) {
    this.staticListener(req, res);
    return;
  }
  var method = req.method.toLowerCase();
  if(method == 'post') {
     var body = '';
     req.on('data', function(data) {
          body += data;
     });
	 req.on('end', function() {
         var post = require('querystring').parse(body);
         req.params = post; //aggancio un nuovo attributo
         doDispatch.call(dispatcher);
     });
  } else {
     var url_parts = require('url').parse(req.url, true);
     req.params = url_parts.query; //aggancio un nuovo attributo
  }
  if(this.listener[method][parsedUrl.pathname]) this.listener[method][parsedUrl.pathname](req, res)
  else this.errorListener(req, res);
}

Una volta modificato in questo modo il modulo sarò possibile accedere ai parametri all'interno del listener semplicemente con un req.params e recuperare tutte le informazioni inviate dal client.

Ovviamente questa modifica è stata inserita nel sorgente del modulo e basterà aggiornare il progetto da npm per poter effettuare le prove in locale.

Nella prossima lezione ci occuperemo della persistenza dei dati su database.