Share
Nykommere til NodeJS finner vanligvis sin API vanskelig å forstå. Heldigvis har mange utviklere laget rammer som gjør det enklere å jobbe med Node. Koble til er et slikt rammeverk. Den sitter på toppen av Node API og trekker linjen mellom komfort og kontroll.
Tenk på Koble til som en stabel med mellomvare. Ved hver forespørsel, Koble filtre gjennom lagene av mellomvare, som hver har mulighet til å behandle HTTP-forespørselen. Når T.J. Holowaychuk kunngjorde Connect, han sa at det var to typer mellomvare. Den første er a filter.
Filter behandler forespørselen, men de svarer ikke på det (tenk på serverlogging).
Den andre typen er a forsørger, som svarer på forespørselen. Du kan innlemme så mange lag med mellomvare som du vil ha; forespørselen går gjennom hvert lag til en av middleware reagerer på forespørselen.
Først må du installere Connect-pakken via npm:
npm installer koble til
Opprett nå en server.js fil, og legg til følgende kode:
Accentsconagua
var connect = krever ("connect"); De koble variabel er en funksjon som returnerer et nytt Connect-program. Så, vårt neste skritt er å lage den appen:
var app = connect ();
Du trenger ikke å opprette en app variabel for de fleste av programmene dine. Funksjonene som er involvert i å lage et program (koble() og bruk()) er kjedbare:
koble til () .use (/ * middleware * /) .use (/ * middleware * /) .listen (3000);
De bruk() funksjon legger til et lag med mellomvare til applikasjonen, og lytte() funksjonen forteller at søknaden vår begynner å akseptere tilkoblinger på den angitte porten (3000 i dette eksemplet).
La oss starte med noe enkelt: logging. Koden for et Koble-program som bare bruker loggingsprogramvare er ganske enkelt:
koble til () .use (connect.logger ()) .listen (3000);
Som standard analyserer noden svært lite av den innkommende forespørselen.
Legg den koden til filen din, og start serveren ved å kjøre node server.js. Naviger til hvilken som helst bane i nettleseren din, og ignorér resultatene "Kan ikke få ...". Vi er ikke interessert i hva serveren sendte tilbake til nettleseren; Vi er interessert i serverens logg. Se på terminalen, og du vil se loggen på dine forespørsler. Husk å sjekke ut loggerdokumentasjonen for informasjon om andre funksjoner og tilpasning.
Det var et filter; La oss nå se på en leverandør. Den enkleste leverandøren er den statiske leverandøren; Den serverer statiske filer fra en spesifisert mappe. Her er dens syntaks:
.bruk (connect.static (__ dirname + "/ public")
Du kan nok gjette formålet med Node __dirname variabel: det er banen til gjeldende katalog. Denne mellomvare serverer statisk alt fra a offentlig mappe i gjeldende katalog. Så opprett offentlig / /side.html og legg til en element. Start serveren på nytt (node server.js), og naviger til localhost: 3000 / /side.html i nettleseren din. Du burde /side.html gjengitt i nettleseren.
La oss nå se på noen av Connects andre mellomvarealternativer.
Som standard analyserer Node svært lite av innkommende forespørsel, men du kan inkludere flere forskjellige filtre for å analysere forespørselen hvis du trenger å håndtere mer kompleksitet. Det er fire filtre:
connect.json () analyserer JSON forespørselsorganer (hvor innholdstype er application / json).connect.urlencoded () analyserer x-ww-skjema-urlencoded forespørsel organer.connect.multipart () analyserer multipart / skjema-data forespørsel organer.connect.bodyParser () er en snarvei for å aktivere alle de tre ovenfor.Ved å bruke noen av disse filtrene, får du muligheten til å få tilgang til den analyserte kroppen via request.body (vi snakker om hvordan du får det be om objekt snart).
Jeg tror disse filtrene er et godt eksempel på hvordan du finfinerer kontrollen din med Connect. Du kan bruke svært lite behandling for å effektivisere applikasjonen din.
Cookies og økter er en viktig del av en hvilken som helst webapplikasjon, og det finnes flere biter av mellomvare som hjelper dem med å håndtere dem. De connect.cookieParser () analyserer informasjonskapsler for deg, og du kan hente informasjonskapslene og deres verdier, via Request.Cookies gjenstand. Dette er mer nyttig hvis du legger til connect.session () filtrer til appen din. Dette filteret krever at cookieparseren allerede er på plass. Her er et lite eksempel:
koble til () .use (connect.cookieParser ()) .use (connect.session (hemmelig: 'noen hemmelig tekst', informasjonskapsel: maxAge: 30000)) .use (funksjon (req, res) = req.session, url = req.url.split ("/"); hvis (url [1] == "navn" && url [2]) sess.name = url [2]; res.end navn lagret: "+ url [2]); else if (sess.name) res.write (" økt lagret navn: "+ sess.name); res.end (" lagret for en annen: "+ .cookie.maxAge / 1000) + "seconds"); else res.end ("ikke lagret navn; gå til / navn / name for å lagre et navn");). Hver mellomvarefunksjon du skriver, må enten sende forespørselen til
nestelag eller svare på forespørselen.
Etter cookieParser, vi inkluderer økt filtrer og send det to alternativer:
hemmelig lager en signert informasjonskapsel som holder øye på økten.cookie.maxAge definerer levetiden i millisekunder; 30000 i denne koden er 30 sekunder.I finalen bruk() ring, vi sender en funksjon som svarer på forespørselen. Vi bruker to egenskaper fra be om gjenstand: req.session for øktdata, og req.url for forespørselsadressen.
Hvis søknaden mottar en forespørsel om / Navn / some_name, da lagrer den verdien some_name i req.session.name. Alt lagret i en økt kan hentes i etterfølgende forespørsler om lengden på økten. Eventuelle forespørsler gjort for / Navn / annet erstatter sesjonsvariabelen, og eventuelle forespørsler til andre nettadresser utfører sessionsvariabelenes verdi og tiden som er igjen for økten.
Så kan du navigere til localhost: 3000 / navn / ditt_navn, og deretter gå til localhost: 3000 å se navnet ditt. Oppdater siden et par ganger og se på sekunder nedtelling. Når sesjonen utløper, vil du se standardmeldingen "Nei lagret navn".
Jeg nevnte at cookieParser filteret må komme før økt.
Ordren for inkludering er viktig med mellomvare fordi forespørselen er bestått, i rekkefølge, fra lag til lag.
Fordi økt trenger informasjonen om parsed informasjon, må forespørselen gå gjennom cookieParser før økt.
Jeg kunne forklare alt annet innebygd stykke mellomvare, men jeg skal bare nevne noen flere før vi skriver vår egen kode til grensesnitt med Connect.
Du har nettopp lært hvordan du skriver din egen kode med Connect. Her er det grunnleggende syntaks igjen:
.bruk (funksjon (req, res, neste) )
Funksjonens tre parametere er viktige; de gir tilgang til omverdenen. De req parameter er selvfølgelig forespørselsobjektet, og res er svaret. Den tredje parameteren, neste, er nøkkelen til å lage funksjoner som fungerer godt i middleware-stakken. Det er en funksjon som overfører forespørselen til neste mellomvare i stabelen. Se dette eksemplet:
Koble til () .use (funksjon (req, res, neste) if (req.method === 'POST') res.end ("Dette er en POST-forespørsel"); else next ) .use (funksjon (req, res) res.end ("Dette er ikke en POST-forespørsel (sannsynligvis en GET-forespørsel)");). Listen (3000); Denne koden bruker to mellomvarefunksjoner. Den første funksjonen kontrollerer forespørselsmetoden for å se om det er en POST-forespørsel. Hvis det er, svarer det ved å si det. Ellers kaller vi neste () og send forespørselen til neste funksjon, som svarer uansett hva. Bruk curl for å teste begge lagene i terminalen:
$ curl http: // localhost: 3000 Dette er ikke en POST-forespørsel (sannsynligvis en GET-forespørsel) $ curl -X POST http: // localhost: 3000 Dette er en POST-forespørsel
Hvis du ikke liker terminalen, kan du prøve dette nyttige Chrome-plugin.
Det er viktig å huske at hver mellomvarefunksjon du skriver, må enten sende forespørselen til neste lag eller svare på forespørselen. Hvis funksjonen din grener (via om setninger eller andre betingelser), må du sørge for at hver gren passerer forespørselen eller svarer på den. Hvis appen din henger i nettleseren, er det sannsynligvis fordi du har glemt å ringe neste () på et tidspunkt.
Nå, hva med dem be om og respons parametere? Disse er de samme forespørselen og svarobjektene du mottar når du bruker en "rå" knuteportserver:
krever ("http"). createServer (funksjon (req, res) // ...). lytt (3000); Hvis du ikke har brukt Node server API før, la meg vise deg hva du kan gjøre med det.
De be om objektet er faktisk en http.IncomingMessage objekt, og dets viktige egenskaper er oppført nedenfor:
req.method forteller deg hvilken HTTP-metode som ble brukt.req.url forteller deg hvilken URL som ble forespurt.req.headers er et objekt med overskriftens navn og verdier.req.query er et objekt med data i en spørringsstreng (for å analysere det, trenger du connect.query () mellomvare på plass).req.body er et objekt av skjemadataene (du trenger litt kroppsparsing mellomvare på plass).req.cookies er et objekt av informasjonen om informasjonskapsel (krever parsing av informasjonskapsler).req.session er et objekt av øktdataene (igjen, du må ha informasjon om kakeparsing og økt mellomvare på plass)Du kan se alt dette på jobb med følgende kode:
connect () .use (connect.query ()) // gir oss req.query .use (connect.bodyParser ()) // gir oss req.body .use (connect.cookieParser ()) // for session .use (connect.session (secret: "asdf")) // gir oss req.session .use (funksjon (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 \ n "); res.write (" req.query: "+ JSON.stringify (req.query) +" \ n \ n "); res.write (" req.body: "+ JSON.stringify (req. body) + "\ n \ n"); res.write ("req.cookies:" + JSON.stringify (req.cookies) + "\ n \ n"); res.write ("req.session:" + JSON.stringify (req.session)); res.end ();). Lytt (3000); Hvis du vil se noe for hver av disse verdiene, må du legge inn noen data til en nettadresse med en spørringsstreng. Følgende bør være nok:
curl -X POST -d "name = Ditt navn" "http: // localhost: 3000 / some / url? some = data"
Med de syv egenskapene kan du klare alle forespørsler du mottar. Jeg tror ikke tilhengere blir brukt ofte (jeg har aldri sett dem i min erfaring), men du kan bruke req.trailers hvis du forventer dem i dine forespørsler (tilhengere er akkurat som overskrifter, men etter kroppen).
Så, hva med ditt svar?
Det raske svarobjektet gir ikke den luksusen som biblioteker (som Express) gir deg. For eksempel kan du ikke svare med et enkelt gjengivelsesanrop til en premade template-i det minste, ikke som standard. Svært lite antas i svaret, så du må fylle ut alle de små detaljene.
Vi starter med statuskoden og svarhodene. Du kan sette alle disse på en gang ved å bruke writeHead () metode. Her er et eksempel fra Node-dokumentene:
var kropp = 'hallo verden'; response.writeHead (200, 'Content-Length': body.length, 'Content-Type': 'text / plain');
Hvis du trenger å sette inn overskrifter individuelt, kan du bruke setHeader () metode:
connect () .use (funksjon (req, res) var godta = req.headers.accept.split (","), body, type; console.log (godta); hvis (accept.indexOf ("application / json ")> -1) type =" application / json "; body = JSON.stringify (melding:" hallo "); annet hvis (accept.indexOf (" text / html ")> -1) = "text / html"; body = " Hallo!
"; else type =" text / plain "; body =" hei! "; res.statusCode = 200; res.setHeader (" Content-Type ", type); res.end (body);). lytt (3000); Legg til denne koden i en fil, start serveren og be om den fra nettleseren. Du har HTML! Kjør nå:
krølle http: // localhost: 3000
Og du får vanlig tekst. For JSON, prøv dette:
krøll -H "godta: søknad / json" http: // localhost: 3000
Alt fra samme nettadresse!
Bruk res.getHeader (navn) hvis du trenger å vite hvilke overskrifter som allerede er angitt. Tou kan også bruke res.removeHeader (navn) for å fjerne en overskrift.
Selvfølgelig er et svar ubrukelig uten en kropp. Som du har sett gjennom denne opplæringen, kan du skrive biter av data til kroppen med res.write () metode. Dette aksepterer et streng eller bufferobjekt som et argument. Hvis det er en streng, er den andre parameteren kodingstypen (den er som standard utf8).
De res.end () Metoden lukker kroppen, men du kan sende data til den for å skrive til responsstrømmen. Dette er nyttig i situasjoner der du bare trenger å utføre en enkelt linje.
Det er noe vanskelig å svare med større HTML-kropper i vanlig gammel Node og Connect. Dette er et bra sted å kaste tredjepart mellomvare i blandingen. Du finner en liste over tredjeparts mellomvare på Connect Github wiki. Som et eksempel skal vi bruke connect-jade-pakken, som gjør at vi kan gjengi jade-visninger.
Først installer koble-jade:
npm installere connect-jade
Deretter krever og legger det til som mellomvare. Du vil angi noen standardverdier:
var connect = krever ("connect"), connectJade = krever ("connect-jade"); Koble til () .use (connectJade (root: __dirname + "/ views), standard: title:" MyApp ")) .use (funksjon (req, res) res.render (" index " : "Velkommen til min app");). Lytt (3000); Sett roten som katalogen som inneholder visningsfilene. Du kan også angi mislighold; Dette er variabler som er tilgjengelige i alle visningene, med mindre vi tilsidesetter dem senere når de ringer render ().
Den endelige funksjonen i denne koden ringer til res.render (). Denne metoden er gitt av koble-jade pakke.
Det første argumentet det aksepterer er navnet på visningen å gjengi.
Det er banen til utsikten, sans stien som vi definerte når du legger til mellomprogramvaren, sans jade filtypen. For denne koden trenger vi en visninger / index.jade mal for å gjengi. Vi vil holde det enkelt:
html head title = tittel kropp h1 = overskrift
Hvis du ikke er kjent med jade, strekker vi inn taggenavn for å lage en HTML-struktur. Liktegnet henter verdien av en JavaScript-variabel. Disse variablene kommer fra mislighold vi satt opp, pluss det (valgfrie) andre parameterobjektet som ble sendt til res.render ().
Det er mange andre tredjeparts middleware, men de fungerer som hverandre. Du installerer dem via npm, krever dem og legger dem til handling.
Hvis du graver deg i hvordan Connect fungerer, vil du oppdage at hvert lag egentlig er en nodemodul - en veldig intelligent design. Hvis du bruker Koble til store applikasjoner, ville det være ideelt å skrive koden i Node-modulformat. Du kan ha en app.js filen som denne:
// app.js module.exports = funksjon (req, res, neste) res.end ("dette kommer fra en modul"); ; Og i din server.js:
var connect = krever ("connect"), app = krever ("./ app"); koble til () .use (app) .listen (3000); Hvis du vil ha et nybegynnervennlig bibliotek som gjør det enkelt å bygge store webapper, er Connect ikke din løsning. Koble til er ment å være et tynt lag på toppen av den rå nodeprogrammet som gir deg full kontroll over serverprogrammet ditt. Hvis du vil ha litt mer, anbefaler jeg Express (av de samme folkene for øvrig). Ellers er Connect et fantastisk, utvidbart bibliotek for Node-webapplikasjoner.
