Share
Noii veniți la NodeJS își găsesc de obicei API greu de înțeles. Din fericire, mulți dezvoltatori au creat cadre care ușurează lucrul cu Nodul. Conectați este un astfel de cadru. Acesta se află pe partea de sus a API-ului Node și trasează linia dintre confort și control.
Gândiți-vă la Conectați ca o stivă de middleware. Cu fiecare cerere, conectați filtrele prin straturile de middleware, fiecare având posibilitatea de a procesa cererea HTTP. Când T.J. Holowaychuk a anunțat Connect, a spus că au existat două tipuri de middleware. Primul este a filtru.
Filtrele procesează cererea, dar nu răspund la aceasta (gândiți-vă la logarea serverului).
Celălalt tip este a furnizor, care răspunde cererii. Puteți integra cât mai multe straturi de middleware așa cum doriți; cererea trece prin fiecare strat până când unul din middleware răspunde cererii.
În primul rând, trebuie să instalați pachetul Connect prin npm:
npm install connect
Acum creați un server.js fișier și adăugați următorul cod:
Accentsconagua
var connect = necesită ("connect"); conectați variabila este o funcție care returnează o nouă aplicație Connect. Deci, următorul nostru pas este să creăm acea aplicație:
var app = conectare ();
Nu este nevoie să creați un aplicaţia variabilă pentru majoritatea aplicațiilor dvs. Funcțiile implicate în crearea unei aplicații (conectați() și utilizare()) sunt flexibile:
conectați () folosiți (/ * middleware * /). folosiți (/ * middleware * /) .listen (3000);
utilizare() funcția adaugă un strat de middleware la aplicație și asculta() funcția spune aplicația noastră să înceapă să accepte conexiuni pe portul specificat (3000 în acest exemplu).
Să începem cu ceva simplu: înregistrare. Codul pentru o aplicație Connect care folosește doar mediul de logare este destul de simplă:
conectați () .Utilizați (connect.logger ()) .listen (3000);
În mod implicit, nodul analizează foarte puțin cererea de intrare.
Adăugați acest cod în fișierul dvs. și porniți serverul rulând nod server.js. Navigați la orice cale din browser și ignorați rezultatele "Nu se poate obține ...". Nu suntem interesați de ceea ce serverul a trimis înapoi la browser; suntem interesați de jurnalul serverului. Uită-te la terminal și vei vedea jurnalul solicitărilor tale. Asigurați-vă că verificați documentația înregistratorului pentru informații despre alte caracteristici și personalizare.
A fost un filtru; acum să ne uităm la un furnizor. Cel mai simplu furnizor este furnizorul static; servește fișiere statice dintr-un dosar specificat. Iată sintaxa sa:
.utilizați (connect.static (__ dirname + "/ public")
Probabil că puteți ghici scopul Nodului __dirname variabilă: este calea spre directorul curent. Acest middleware servește în mod static ceva de la a public folder din directorul curent. Deci, creați publice / pagină.html și adăugați un element. Reporniți serverul (nod server.js) și navigați la localhost: 3000 / pagină.html în browserul dvs. Tu ar trebui pagină.html redată în browser.
Să examinăm acum câteva dintre celelalte opțiuni middleware ale Connect.
În mod implicit, Nodul parsează foarte puțin cererea de intrare, dar puteți include mai multe filtre diferite pentru a analiza cererea dacă aveți nevoie să faceți față cu mai multă complexitate. Există patru filtre:
connect.json () analizează organismele de cerere ale JSON (unde tipul de conținut este application / json).connect.urlencoded () analizează x-ww-form-urlencoded solicită organismele.connect.multipart () analizează multipart / form-data solicită organismele.connect.bodyParser () este o scurtătură pentru a permite tuturor celor trei de mai sus.Utilizarea oricăruia dintre aceste filtre vă oferă posibilitatea de a accesa corpul dvs. parsat prin request.body (vom vorbi despre cum să obținem asta cerere obiect în curând).
Cred că aceste filtre sunt un bun exemplu pentru modul în care puteți să vă îmbogățiți controlul cu Connect. Puteți utiliza foarte puțin procesare pentru a simplifica aplicația.
Cookie-urile și sesiunile sunt o parte importantă a oricărei aplicații web și există câteva piese de middleware care ajută la gestionarea lor. connect.cookieParser () sortează cookie-urile pentru tine și poți extrage cookie-urile și valorile lor prin intermediul request.cookies obiect. Acest lucru este mai util dacă adăugați connect.session () filtrați aplicația dvs. Acest filtru necesită deja parserul cookie-urilor. Iată un mic exemplu:
(secret: 'secret secret', cookie: maxAge: 30000)) .use (functie (req, res) var sess (conect.cookieParser = req.session, url = req.url.split ("/"); dacă (url [1] == "nume" && url [2]) sess.name = url [ nume salvat: "+ url [2]); altceva dacă (sess.name) res.write (" nume stocat în sesiune: "+ sess.name); res.end .cookie.maxAge / 1000) + "secunde"); altceva res.end ("nici un nume stocat, mergeți la / nume / nume pentru a salva un nume"); Fiecare funcție middleware pe care o scrieți trebuie fie să treacă cererea la
Următor →layer sau răspundeți la cerere.
După cookieParser, noi includem sesiune filtrați-l și treceți-l cu două opțiuni:
secret creează un cookie semnat care ține evidența sesiunii.cookie.maxAge își definește durata de viață în milisecunde; codul 30000 din acest cod este de 30 de secunde.In final utilizare() apel, trecem o funcție care răspunde cererii. Utilizăm două proprietăți din cerere obiect: req.session pentru datele de sesiune și req.url pentru adresa URL a solicitării.
Dacă cererea primește o cerere / Numele / some_name, apoi stochează valoarea some_name în req.session.name. Orice stocat în cadrul unei sesiuni poate fi preluat în cererile ulterioare pentru durata sesiunii. Orice solicitări făcute / Numele / altele înlocuiește variabila de sesiune și orice solicitare adresată altor adrese URL afișează valoarea variabilei sesiunii și timpul rămas pentru sesiune.
Deci, puteți naviga la localhost: 3000 / Nume / your_name, și apoi du-te la localhost: 3000 a vedea Numele dumneavoastră. Reîmprospătați pagina de câteva ori și urmăriți numărătoarea secundelor. Când expiră sesiunea, veți vedea mesajul implicit "fără nume memorat".
Am menționat că cookieParser filtrul trebuie să vină înainte sesiune.
Ordinea includerii este importantă pentru middleware deoarece cererea este transmisă, în ordine, de la strat la strat.
pentru că sesiune are nevoie de datele cookie parsate, cererea trebuie să treacă cookieParser inainte de sesiune.
Aș putea explica fiecare altă piesă de middleware încorporată, dar voi menționa doar câteva altele înainte de a scrie propriul cod pentru a interfața cu Connect.
Tocmai ați învățat cum să scrieți propriul cod cu Connect. Iată sintaxa de bază din nou:
.(funcția (req, res, următorul) )
Cei trei parametri ai funcției sunt importanți; ele oferă acces la lumea exterioară. req parametru este, desigur, obiectul cerere, și res este răspunsul. Al treilea parametru, Următor →, este cheia pentru a face funcții care funcționează bine în stadiul middleware. Este o funcție care transmite cererea către următorul middleware din stivă. Vedeți acest exemplu:
connect () .use (funcția (req, res, urm)) if (req.method === 'POST') res.end ("Aceasta este o cerere POST" ) .use (functie (req, res) res.end ("Aceasta nu este o cerere POST (probabil o cerere GET)");)) asculta (3000); Acest cod utilizează două funcții middleware. Prima funcție verifică metoda solicitării pentru a vedea dacă este o solicitare POST. Dacă este, răspunde așa. În caz contrar, sunăm Următor →() și transmite cererea la următoarea funcție, care răspunde indiferent de ce. Utilizare răsuci pentru a testa ambele straturi în terminal:
$ curl http: // localhost: 3000 Aceasta nu este o cerere POST (probabil o solicitare GET) $ curl -X POST http: // localhost: 3000 Aceasta este o cerere POST
Dacă nu vă place terminalul, încercați acest plugin Chrome util.
Este important să rețineți că fiecare funcție middleware pe care o scrieți trebuie fie să treacă cererea la Următor → layer sau răspundeți la cerere. Dacă funcția dvs. se încadrează (prin declarații sau prin alte condiții), trebuie să vă asigurați că fiecare ramură trece solicitarea sau răspunde la aceasta. Dacă aplicația dvs. se blochează în browser, probabil că ați uitat să suni Următor →() la un moment dat.
Acum, ce zici de asta? cerere și raspuns parametri? Acestea sunt aceleași obiecte de solicitare și de răspuns pe care le primiți când utilizați un server de noduri "prime":
cere ("http") createServer (funcția (req, res) // ...) asculta (3000); Dacă nu ați folosit API-ul serverului Node înainte, permiteți-mi să vă arăt ce puteți face cu acesta.
cerere obiect este de fapt un http.IncomingMessage obiect și proprietățile sale importante sunt enumerate mai jos:
req.method vă spune ce metodă HTTP a fost utilizată.req.url vă indică adresa URL solicitată.req.headers este un obiect cu numele și valorile antetului.req.query este un obiect cu orice date dintr-un șir de interogări (pentru a analiza acest lucru, veți avea nevoie de connect.query () middleware în loc).req.body este un obiect al datelor formularului (veți avea nevoie de un mijloc de partajare a middleware-ului în loc).req.cookies este un obiect al datelor cookie (necesită parsarea cookie-urilor).req.session este un obiect al datelor din sesiune (din nou, veți avea nevoie de parsarea cookie-urilor și de middleware-ul sesiunii)Puteți vedea toate acestea la lucru cu următorul cod:
connect () .use (connect.query ()) // ne dă req.query .use (connect.bodyParser ()) // ne dă req.body .use (connect.cookieParser ()) // pentru sesiune. (req, res) res.write ("req.url:" + req.url + "\ n \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\" n "); res.write (" req.method: "+ req.method +" \ n \ n "); res.write (" req.headers: "+ JSON.stringify (req.headers) \ n "); res.write (" req.query: "+ JSON.stringify (req.query) +" \ n \ n "); res.write (" req.body: "+ JSON.stringify (req. ); res.write ("req.cookies:" + JSON.stringify (req.cookies) + "\ n \ n"); JSON.stringify (req.session)); res.end ();) asculta (3000); Pentru a vedea ceva pentru fiecare dintre aceste valori, trebuie să publicați unele date într-o adresă URL cu un șir de interogări. Ar trebui să fie suficiente următoarele:
curl -X POST -d "nume = YourName" "http: // localhost: 3000 / some / url? some = data"
Cu cele șapte proprietăți, puteți gestiona orice solicitare pe care o veți primi. Nu cred că remorcile sunt folosite frecvent (nu le-am văzut niciodată în experiența mea), dar le puteți folosi req.trailers dacă vă așteptați în cererile dvs. (remorcile sunt la fel ca și anteturile, dar după corp).
Și răspunsul tău?
Obiectul de răspuns brut nu oferă luxul pe care îl oferă bibliotecile (cum ar fi Express). De exemplu, nu puteți răspunde cu un simplu apel de redare unui șablon de premadă - cel puțin, nu în mod implicit. În răspuns este foarte puțin presupusă, deci trebuie să completați toate detaliile.
Vom începe cu codul de stare și antetele de răspuns. Puteți seta toate acestea simultan folosind writeHead () metodă. Iată un exemplu din documentul nodului:
var corp = 'salut lume'; response.writeHead (200, 'Content-Length': body.length, 'Content-Type': 'text / plain');
Dacă trebuie să setați individual anteturi, puteți utiliza setHeader () metodă:
(accept), dacă (acceptați.indexOf ("aplicație / json")), folosiți funcția (req, res) var accept = req.headers.accept.split "> -1) type =" application / json "; body = JSON.stringify (message: hello; else if (accept.indexOf (text / html) = "text / html"; corp = " Salut!
"altceva type =" text / plain "; corp =" hello! "; res.statusCode = 200; res.setHeader (" Content-Type "; asculta (3000); Adăugați acest cod într-un fișier, porniți serverul și solicitați-l din browser. Ai HTML! Acum rulați:
curl http: // localhost: 3000
Și veți primi text simplu. Pentru JSON, încercați acest lucru:
curl -H "acceptă: application / json" http: // localhost: 3000
Totul de la aceeași adresă URL!
Utilizare res.getHeader (nume) dacă trebuie să știți ce anteturi au fost deja stabilite. De asemenea, puteți utiliza res.removeHeader (nume) pentru a elimina un antet.
Desigur, un răspuns este inutil fără un corp. După cum ați văzut pe parcursul acestui tutorial, puteți scrie bucăți de date corpului cu res.write () metodă. Aceasta acceptă ca argument un șir sau un obiect tampon. Dacă este un șir, al doilea parametru este tipul de codare (acesta este implicit la utf8).
res.end () metoda închide corpul, dar puteți transmite date către el pentru a scrie în fluxul de răspuns. Acest lucru este util în situațiile în care trebuie doar să trimiteți o singură linie.
Este oarecum dificil să răspundeți cu corpuri HTML mai mari în nodul simplu vechi și Connect. Acesta este un loc bun pentru a arunca middleware-ul terților în amestec. Puteți găsi o listă de middleware terță parte în wiki Connect Github. De exemplu, vom folosi pachetul connect-jade, care ne permite să facem vederi de jad.
Mai întâi, instalați-o conectați-jad:
npm instalați conex-jade
Apoi, solicitați și adăugați-l ca middleware. Veți dori să setați câteva valori implicite:
var connect = necesită ("connect"), connectJade = necesită ("connect-jade"); conectați () folosiți (connectJade (rădăcină: __dirname + "/ views", implicit: title: "MyApp")) .use (funcția (req, res) res.render : "Bun venit la aplicația mea");). Asculta (3000); Setați rădăcina ca director care conține fișierele de vizualizare. De asemenea, puteți seta implicite; acestea sunt variabile disponibile în interiorul fiecărei vizualizări, cu excepția cazului în care le suprascriu mai târziu când sunăm face().
Funcția finală din acest cod face apel la res.render (). Această metodă este furnizată de conectați-jad pachet.
Primul argument pe care îl acceptă este numele viziunii de a face.
Este calea spre vedere, sans calea pe care am definit-o la adăugarea middleware-ului, sans extensia de fișier jad. Pentru acest cod, avem nevoie de a vizualizari / index.jade șablon pentru a face. Vom păstra simplu:
html titlu titlu = titlu corp h1 = titlu
Dacă nu sunteți familiarizați cu jad, vom indent numele de tag-uri pentru a crea o structură HTML. Semnul egal preia valoarea unei variabile JavaScript. Aceste variabile provin din implicite am setat, plus obiectul (opțional) al doilea parametru trecut la res.render ().
Există multe alte middleware de la terți, dar ele funcționează similar unul cu celălalt. Le instalați prin intermediul npm, le cereți și le puneți în acțiune.
Dacă vă aflați în modul în care funcționează Conectarea, veți observa că fiecare strat este de fapt un modul Nod - un design foarte inteligent. Dacă utilizați Conectare pentru aplicații mari, ar fi ideal să scrieți codul în modulul Nod. S-ar putea să ai un app.js fișier ca acesta:
// app.js module.exports = funcția (req, res, next) res.end ("aceasta vine de la un modul"); ; Și în tine server.js:
var connect = necesită ("connect"), app = necesită ("./ app"); conectați () .utilizați (app) .listen (3000); Dacă doriți o bibliotecă prietenoasă pentru începători care să faciliteze crearea unor aplicații web mari, atunci Connect nu este soluția dvs. Conectarea este menită a fi un strat subțire deasupra API-ului Node raw, care vă oferă control complet asupra aplicației server. Dacă doriți un pic mai mult, vă recomand Express (de către aceiași oameni, întâmplător). Altfel, Connect este o bibliotecă fantastică, extensibilă pentru aplicațiile web Node.
