Sommario
Il Modulo HTTP all'interno delle nostre applicazioni scritte in Nodo.js Ci aiutano a costruire parte delle funzionalità per dare vita ai nostri server, tuttavia questo non è l'uso esclusivo che possiamo dare a questo modulo.Il vero potere di HTTP viene visualizzato quando utilizziamo il tuo oggetto per elaborare le diverse richieste o richiesta che possono provenire dalla nostra applicazione, con questo possiamo elaborare i dati che provengono da INVIARE tramite moduli o richieste dei clienti RIPOSO.
Requisiti dell'esercitazionePer svolgere gli esercizi proposti in questo tutorial dobbiamo avere un'installazione funzionale di Nodo.js nel nostro sistema e disporre delle autorizzazioni per accedervi. È anche importante poter avere accesso a un editor di testo ricco per codificare gli esempi, possiamo usare qualunque cosa ci sentiamo a nostro agio, tuttavia, per la sua facilità d'uso, consigliamo Testo sublime o Blocco note ++ che hanno anche componenti aggiuntivi per la sintassi JavaScript sì HTML.
Elaborazione dati INVIARE ci consente di acquisire dati dai moduli, con questo possiamo gestire i dati che provengono dalle interazioni dell'utente con le nostre applicazioni, consentendoci così di implementare logiche di business per elaborare tali dati.
Il modo più diretto che abbiamo per elaborare i dati INVIARE è finita Oggetto HTTP, attraverso l'interazione diretta con il metodo creaServer() possiamo identificare il tipo di metodo della richiesta, sia INVIARE o OTTENERE e persino METTERE sì ELIMINA.
Se siamo osservatori vediamo che questo ci fa pensare alle nostre applicazioni in un certo senso Riposante, cioè, possiamo comunicare con esso attraverso diversi client e non necessariamente con moduli HTMLTuttavia, questo è un argomento che va oltre questo tutorial.
La prima cosa che faremo è creare un piccolo modulo che ci permetterà di catturare i dati della nostra applicazione nel browser, per questo creeremo un file chiamato form.html nella directory o nella cartella della nostra applicazione.
Quest'ultimo non è consigliato in un ambiente di produzione quindi lo prenderemo solo come riferimento per poter dimostrare come funziona il sistema. Oggetto HTTP. Il codice del nostro modulo sarà il seguente:
Come possiamo vedere, indichiamo semplicemente al nostro modulo che deve utilizzare il metodo INVIARE, abbiamo un paio di campi di testo e infine un pulsante Invia per inviare i nostri dati al server.
Ora dobbiamo creare il server Nodo.js che ci aiuterà a raccogliere i dati dal modulo, qui dobbiamo prendere in considerazione due possibilità, la prima è quando accediamo al percorso della nostra applicazione, questo utilizzerà il metodo OTTENERE ed è qui che dovremmo mostrare la nostra forma.
La seconda possibilità è quando vengono inviati i dati del modulo e per questo dobbiamo convalidare il metodo INVIARE che è l'obiettivo dell'esercizio. Per poter visualizzare il modulo, dobbiamo creare un componente sincrono che legga il nostro file form.html e servirlo nel percorso corrispondente, per questo possiamo fare affidamento sul metodo leggiF.webpileSync del modulo fs.
Nella parte successiva dobbiamo fare in modo che il nostro server possa gestire i dati INVIARE, per questo mostreremo semplicemente ciò che riceviamo nella console con il metodo console.log(), in questo modo possiamo confermare che tutto funziona correttamente, vediamo il codice iniziale per ottenere ciò che vogliamo:
var http = require ('http'); var querystring = require ('querystring'); var util = require ('util'); var form = require ('fs'). readFileSync ('form.html'); http .createServer (function (request, response) {if (request.method === "POST") {var dataPost = ''; request.on ('data', function (chunk) {dataPost + = chunk;}). on ('end', function() {var dataPostObject = querystring.parse (dataPost); console.log ('Dati inviati dall'utente: \ n', dataPost); response.end ('Hai inviato dati: \ n '+ util.inspect (dataPostObject));});} if (request.method === "GET") {response.writeHead (200, {' Content-Type ':' text / html '}); response. end ( form);}}).ascolta (8082);Per rendere tutto il più leggibile possibile, i moduli sono stati inoltre incorporati stringa della domanda sì Utile, con loro possiamo elaborare le informazioni che provengono dal server e quindi essere in grado di manipolarle per stamparle.Vediamo come dovrebbe apparire inizialmente il nostro modulo quando avviamo la nostra applicazione e apriamo il browser nel percorso principale del progetto:
INGRANDIRE
Sebbene l'esempio precedente funzioni correttamente, ha alcuni punti deboli che se l'applicazione dovesse andare in produzione, potrebbe causarci più mal di testa, ad esempio, cosa succede se ci invia più dati di quelli che la memoria del nostro server può supportare, ovviamente il nostro l'intera struttura crollerebbe. Se riceviamo dati da INVIARE vuoto, nello stato attuale della nostra applicazione fallirebbe e otterremmo un errore che causerebbe l'arresto anomalo del nostro servizio e smetterebbe di funzionare.
Per correggere questi difetti dobbiamo semplicemente incorporare alcune convalide molto semplici, prima di tutto incorporeremo una variabile che ci aiuterà a limitare i dati ricevuti a un massimo di 2 MBQuesto può darci un po' di sicurezza che almeno con pochi utenti non sarà possibile che il sistema vada in crash. Poi lo valuteremo in modo che la nostra richiesta INVIARE essere elaborato su Oggetto HTTP che lo contiene non può essere vuoto, quindi ci assicuriamo che non ci siano guasti diretti nel nostro server. Diamo un'occhiata al codice sopra con le modifiche appropriate:
var http = require ('http'); var querystring = require ('querystring'); var util = require ('util'); var form = require ('fs'). readFileSync ('form.html'); var maxData = 2 * 1024 * 1024; http.createServer (function (request, response) {if (request.method === "POST") {var dataPost = ''; request.on ('data', function (chunk) {dataPost + = chunk; if ( dataPost.length> maxData) {dataPost = ''; this.destroy (); response.writeHead (413); response.end ('I dati inseriti superano la nostra capacità');}}). on ('end', funzione () {if (! PostData) {response.end (); return;} var ObjectPostData = querystring.parse (PostData); console.log ('L'utente ha inviato i dati: \ n', PostData); response.end ( 'Hai inviato i dati: \ n' + util.inspect (datosPostObjeto));});} if (request.method === "GET") {response.writeHead (200, {'Content-Type': ' text/html '}); response.end (form);}}). listen (8082);Se riceviamo dati maggiori di 2 MB scriviamo semplicemente un'intestazione HTTP 413 ad indicare il caso e distruggiamo immediatamente i dati ricevuti per non mantenere inutilmente il carico sul nostro server.Nel caso in cui riceviamo dati vuoti da INVIARE, continuiamo semplicemente la nostra esecuzione impedendo che il servizio si spenga inaspettatamente.
Un altro uso che possiamo dare al metodo INVIARE di HTTP è essere in grado di ricevere file, per questo dobbiamo installare un complemento nel nostro sistema ed è il pacchetto formidabile, per raggiungere questo obiettivo nella console Nodo.js eseguiremo il seguente codice:
npm install [email protected]Questo dovrebbe essere il seguente:
Fondamentalmente quello che abbiamo fatto è stato modificare l'intestazione del modulo in modo che il nostro server sappia che riceverà qualcosa di più del semplice testo e abbiamo anche cambiato i campi di testo in file. Finalmente andiamo a modificare il nostro file server.js e inseriremo il seguente codice:
var http = require ('http'); var formidable = require ('formidable'); var form = require ('fs'). readFileSync ('form.html'); http.createServer (function (request, response) { if (request.method === "POST") {var incoming = new formidable.IncomingForm (); incoming.uploadDir = 'files'; incoming.on ('file', function (field, file) {if (! file .size) {return;} response.write (file.name + 'received \ n');}). on ('end', function () {response.end ('Tutti i file sono stati ricevuti');}); incoming.parse (request);} if (request.method === "GET") {response.writeHead (200, {'Content-Type': 'text/html'}); response.end (form); } }).ascolta (8082);Vediamo come il modulo formidabile è colui che ci aiuta a elaborare il caricamento dei file, questo li memorizzerà in una cartella chiamata record, che per far funzionare la cartella di destinazione deve avere il permesso di scrittura per Nodo.js.Con quest'ultimo abbiamo terminato il nostro tutorial, come abbiamo visto abbiamo più opzioni con cui possiamo elaborare le richieste INVIARE usando l'oggetto HTTP sul nostro server Nodo.js, oltre a tutti i vantaggi che aggiunge ai nostri sviluppi.
