Share
Node.js è tutto il buzz al momento, e rende facile la creazione di applicazioni web in tempo reale ad alte prestazioni. Permette l'uso di JavaScript end-to-end, sia sul server che sul client. Questo tutorial ti guiderà attraverso l'installazione di Node e il tuo primo programma "Hello World", per costruire un server Twitter di streaming scalabile.
JavaScript ha tradizionalmente eseguito solo nel browser web, ma recentemente c'è stato anche un notevole interesse nel portarlo sul lato server, grazie al progetto CommonJS. Altri ambienti JavaScript lato server includono Jaxer e Narwhal. Tuttavia, Node.js è un po 'diverso da queste soluzioni, perché è basato su eventi anziché su thread. I server Web come Apache utilizzati per servire PHP e altri script CGI sono basati su thread perché generano un thread di sistema per ogni richiesta in ingresso. Mentre questo va bene per molte applicazioni, il modello basato su thread non si adatta bene a molte connessioni di lunga durata come se fossero necessarie per servire applicazioni in tempo reale come Friendfeed o Google Wave.
"Ogni operazione di I / O in Node.js è asincrona ..."
Node.js, utilizza un ciclo di eventi anziché thread ed è in grado di ridimensionare a milioni di connessioni simultanee. Sfrutta il fatto che i server trascorrono la maggior parte del loro tempo in attesa di operazioni di I / O, come leggere un file da un disco rigido, accedere a un servizio Web esterno o aspettare che un file finisca di essere caricato, perché queste operazioni sono molto più lente che nelle operazioni di memoria. Ogni operazione di I / O in Node.js è asincrona, il che significa che il server può continuare a elaborare le richieste in arrivo mentre è in corso l'operazione di I / O. JavaScript è estremamente adatto alla programmazione basata sugli eventi perché ha funzioni anonime e chiusure che rendono la definizione dei callback inline un gioco da ragazzi, e gli sviluppatori JavaScript sanno già come programmare in questo modo. Questo modello basato su eventi rende Node.js molto veloce e semplifica notevolmente il ridimensionamento delle applicazioni in tempo reale.
Node.js gira su sistemi basati su Unix, come Mac OS X, Linux e FreeBSD. Sfortunatamente, Windows non è ancora supportato, quindi se sei un utente Windows, puoi installarlo su Ubuntu Linux usando Virtualbox. Per fare ciò, segui questo tutorial. Dovrai utilizzare il terminale per installare ed eseguire Node.js.
cd / path / to / nodejs make sudo make install
Molti messaggi verranno inviati al terminale mentre Node.js viene compilato e installato.
Ogni nuova tecnologia inizia con un "Ciao mondo!" tutorial, quindi creeremo un semplice server HTTP che serve quel messaggio. Prima, tuttavia, devi capire il sistema del modulo Node.js. Nel nodo, la funzionalità è incapsulata in moduli che devono essere caricati per poter essere utilizzati. Ci sono molti moduli elencati nella documentazione di Node.js. Carichi questi moduli usando il richiedere funzione in questo modo:
Accentsconagua
var sys = require ("sys"); Questo carica il modulo sys, che contiene funzioni per gestire attività a livello di sistema come stampare l'output sul terminale. Per usare una funzione in un modulo, la chiami sulla variabile in cui hai archiviato il modulo, nel nostro caso SYS.
sys.puts ("Hello World!"); Esecuzione di queste due linee è semplice come eseguire il nodo comando con il nome file del file javascript come argomento.
nodo test.js
Questo produrrà "Hello World!" alla riga di comando quando viene eseguito.
Per creare un server HTTP, è necessario richiedere il http modulo.
var sys = require ("sys"), http = require ("http"); http.createServer (function (request, response) response.sendHeader (200, "Content-Type": "text / html"); response.write ("Hello World!"); response.close (); ) .listen (8080); sys.puts ("Server in esecuzione su http: // localhost: 8080 /"); Questo script importa il file SYS e http moduli e crea un server HTTP. La funzione anonima che è passata http.createServer sarà chiamato ogni volta che una richiesta arriva al server. Una volta creato il server, gli viene detto di ascoltare sulla porta 8080. Quando arriva una richiesta al server, prima inviamo intestazioni HTTP con il tipo di contenuto e il codice di stato di 200 (riuscito). Quindi inviamo "Hello World!" e chiudi la connessione. Potresti notare che dobbiamo chiudere esplicitamente la connessione. Ciò renderà molto semplice lo streaming dei dati al client senza chiudere la connessione. Se esegui questo script e vai a http: // localhost: 8080 / nel tuo browser, vedrai "Hello World!"
OK, quindi abbiamo creato un server HTTP, ma non invia nulla eccetto per "Hello World", indipendentemente dall'URL a cui ti rivolgi. Qualsiasi server HTTP deve essere in grado di inviare file statici come file HTML, immagini e altri file. Il seguente codice fa proprio questo:
var sys = require ("sys"), http = require ("http"), url = require ("url"), percorso = require ("percorso"), fs = require ("fs"); http.createServer (funzione (richiesta, risposta) var uri = url.parse (request.url) .pathname; var nomefile = path.join (process.cwd (), uri); path.exists (nomefile, funzione (esiste ) if (! exists) response.sendHeader (404, "Content-Type": "text / plain"); response.write ("404 Not Found \ n"); response.close (); return; fs.readFile (filename, "binary", function (err, file) if (err) response.sendHeader (500, "Content-Type": "text / plain"); response.write (err + "\ n"); response.close (); return; response.sendHeader (200); response.write (file, "binary"); response.close ();););). listen ( 8080); sys.puts ("Server in esecuzione su http: // localhost: 8080 /"); Iniziamo richiedendo tutti i moduli di cui abbiamo bisogno nel nostro codice. Questo include il SYS, http, url, sentiero, e fs o moduli del filesystem. Quindi creiamo un server HTTP come abbiamo fatto prima. Questa volta, useremo il url modulo per analizzare l'URL in entrata della richiesta e trovare il percorso del file a cui si accede. Usiamo il nome file effettivo sul disco rigido del server path.join, che si unisce process.cwd (), o la directory di lavoro corrente, con il percorso del file richiesto. Successivamente, controlliamo se il file esiste, che è un'operazione asincrona e quindi richiede un callback. Se il file non esiste, un messaggio 404 non trovato viene inviato all'utente e la funzione restituisce. Altrimenti, leggiamo il file usando il fs modulo che utilizza la codifica "binaria" e invia il file all'utente. Se c'è un errore nella lettura del file, presentiamo il messaggio di errore all'utente e chiudiamo la connessione. Poiché tutto ciò è asincrono, il server è in grado di servire altre richieste durante la lettura del file dal disco, indipendentemente da quanto sia grande.
Se si esegue questo esempio e si naviga verso http: // localhost: 8080 / path / to / file di, quel file verrà mostrato nel tuo browser.
Basandoci sul nostro file server statico, costruiremo un server in Node.js che trasmette i tweet a un client che viene servito attraverso il nostro file server statico. Per iniziare, avremo bisogno di un modulo aggiuntivo in questo esempio: il eventi modulo. Node ha un concetto chiamato an EventEmitter, che viene utilizzato dappertutto per gestire i listener di eventi per attività asincrone. Proprio come in jQuery o in un'altra struttura JavaScript lato client in cui si associano i listener di eventi a clic del mouse e richieste AJAX, il nodo consente di associare gli ascoltatori di eventi a molte cose, alcune delle quali sono già state utilizzate. Questi includono ogni operazione di I / O, come la lettura di un file, la scrittura di un file, la verifica della presenza di un file, l'attesa di richieste HTTP, ecc. EventEmitter astrae la logica di legare, sciogliere e scatenare tali ascoltatori di eventi. Useremo un EventEmitter per avvisare gli ascoltatori quando vengono caricati nuovi tweet. Le prime righe del nostro tweet streamer importa tutti i moduli richiesti e definisce una funzione per la gestione dei file statici, che è stata presa dal nostro esempio precedente.
var sys = require ("sys"), http = require ("http"), url = require ("url"), percorso = require ("percorso"), fs = require ("fs"), events = require ( "eventi"); function load_static_file (uri, response) var filename = path.join (process.cwd (), uri); path.exists (filename, function (exists) if (! exists) response.sendHeader (404, "Content-Type": "text / plain"); response.write ("404 Not Found \ n") ; response.close (); return; fs.readFile (filename, "binary", function (err, file) if (err) response.sendHeader (500, "Content-Type": "text / plain" ); response.write (err + "\ n"); response.close (); return; response.sendHeader (200); response.write (file, "binary"); response.close ();) ;); Abbiamo usato il http modulo per creare un server prima, ma è anche possibile creare un client HTTP utilizzando il modulo. Creeremo un client HTTP per caricare i tweet dalla timeline pubblica di Twitter, che viene eseguita da get_tweets funzione.
var twitter_client = http.createClient (80, "api.twitter.com"); var tweet_emitter = new events.EventEmitter (); function get_tweets () var request = twitter_client.request ("GET", "/1/statuses/public_timeline.json", "host": "api.twitter.com"); request.addListener ("response", function (response) var body = ""; response.addListener ("data", function (data) body + = data;); response.addListener ("end", function ( ) var tweets = JSON.parse (body); if (tweets.length> 0) tweet_emitter.emit ("tweets", tweets););); request.close (); setInterval (get_tweets, 5000); Per prima cosa, creiamo un client HTTP sulla porta 80 su api.twitter.com e ne creiamo uno nuovo EventEmitter. Il get_tweets la funzione crea una richiesta HTTP "GET" sulla timeline pubblica di Twitter e aggiunge un listener di eventi che verrà attivato quando i server di Twitter risponderanno. Poiché Node.js è asincrono, i dati nel corpo della risposta arrivano in blocchi, che vengono rilevati dal listener "dati" della risposta. Questo ascoltatore aggiunge semplicemente il pezzo al corpo variabile. Una volta che tutti i blocchi sono entrati, viene attivato il listener di "fine" e analizziamo i dati JSON in arrivo. Se viene restituito più di un tweet, noi emettere l'evento "tweets" sul nostro tweet_emitter, e passa alla serie di nuovi tweet. Ciò attiverà tutti gli ascoltatori di eventi che ascoltano l'evento "tweets" e invierà i nuovi tweet a ciascun client. Riteniamo i nuovi tweet ogni cinque secondi, usando setInterval.
Infine, dobbiamo creare il server HTTP per gestire le richieste.
http.createServer (function (request, response) var uri = url.parse (request.url) .pathname; if (uri === "/ stream") var listener = tweet_emitter.addListener ("tweets", function ( tweets) response.sendHeader (200, "Content-Type": "text / plain"); response.write (JSON.stringify (tweets)); response.close (); clearTimeout (timeout);); var timeout = setTimeout (function () response.sendHeader (200, "Content-Type": "text / plain"); response.write (JSON.stringify ([])); response.close (); tweet_emitter .removeListener (listener);, 10000); else load_static_file (uri, response);). listen (8080); sys.puts ("Server in esecuzione su http: // localhost: 8080 /"); Proprio come abbiamo fatto con il nostro file server statico, creiamo un server HTTP che ascolta sulla porta 8080. Analizziamo l'URL richiesto, e se l'URL è uguale a "/ Stream", lo gestiremo, altrimenti passeremo la richiesta al nostro file server statico. Lo streaming consiste nel creare un listener per ascoltare nuovi tweet sul nostro tweet_emitter, che sarà innescato dal nostro get_tweets funzione. Creiamo anche un timer per uccidere le richieste che durano più di 10 secondi inviando loro una matrice vuota. Quando arrivano nuovi tweet, inviamo i tweet come dati JSON e cancelliamo il timer. Vedrai come funziona meglio dopo aver visto il codice lato client, che è sotto. Salva come test.html nella stessa directory del lato server JavaScript.
Tweet Streamer
Qui, abbiamo una semplice pagina HTML che importa la libreria jQuery e definisce una lista non ordinata in cui inserire i tweet. Il nostro lato client JavaScript memorizza nella cache l'elenco dei tweet ed esegue la load_tweets funzione dopo un secondo. Ciò fornisce al browser il tempo necessario per completare il caricamento della pagina prima di avviare la richiesta AJAX sul server. Il load_tweets la funzione è molto semplice: usa jQuery getJSON funzione da caricare / ruscello. Quando arriva una risposta, passiamo in rassegna tutti i tweet e li aggiungiamo alla lista dei tweet. Quindi, chiamiamo load_tweets ancora. Questo crea efficacemente un ciclo che carica nuovi tweet, che scade dopo dieci secondi a causa del timeout sul server. Ogni volta che ci sono nuovi tweet, vengono inviati al client che mantiene una connessione continua al server. Questa tecnica è chiamata polling lungo.
Se si esegue il server utilizzando nodo e vai a http: // localhost: 8080 / test.html, vedrai lo stream della timeline pubblica di Twitter nel tuo browser.
Node.js è una tecnologia molto eccitante che semplifica la creazione di applicazioni in tempo reale ad alte prestazioni. Spero che tu possa vedere i suoi benefici e che possa usarlo in alcune delle tue applicazioni. Grazie al grande sistema di moduli di Node, è facile usare il codice scritto nell'applicazione e ci sono molti moduli di terze parti disponibili per quasi tutto - inclusi i livelli di connessione del database, i motori di template, i client di posta e persino interi framework che connettono tutti questi cose insieme. Puoi vedere un elenco completo di moduli sul wiki Node.js e più tutorial sul nodo possono essere trovati su How To Node. Ti consiglio inoltre di guardare un video da JSConf, in cui Ryan Dahl, il creatore di Node, descrive la filosofia di design di Node. Questo è disponibile .
Spero ti sia piaciuto questo tutorial. Se hai commenti, puoi lasciarne uno qui o mandarmi un messaggio su Twitter. Buon nodoso!
