Share
Nykomlingar till NodeJS tycker oftast att dess API är svårt att förstå. Lyckligtvis har många utvecklare skapat ramar som gör det enklare att arbeta med Node. Anslut är en sådan ram. Den sitter ovanpå Node API och gör linjen mellan komfort och kontroll.
Tänk på Anslut som en stapel med middleware. Med varje förfrågan, Anslut filter genom lagren av middleware, var och en med möjlighet att behandla HTTP-förfrågan. När T.J. Holowaychuk meddelade Connect, sade han att det fanns två typer av middleware. Den första är a filtrera.
Filter hanterar begäran, men de svarar inte på det (tänk på serverns loggning).
Den andra typen är a leverantör, som svarar på begäran. Du kan inkludera så många lager av middleware som du vill ha; begäran går igenom varje lager tills en av middleware svarar på begäran.
Först måste du installera Connect-paketet via npm:
npm installera ansluta
Skapa nu en server.js fil och lägg till följande kod:
Accentsconagua
var connect = kräver ("connect"); De ansluta variabel är en funktion som returnerar en ny Connect-applikation. Så, vårt nästa steg är att skapa den appen:
var app = connect ();
Du behöver inte skapa en app variabel för de flesta av dina applikationer. Funktionerna med att skapa en ansökan (ansluta() och använda sig av()) är kedjbara:
anslut () .use (/ * middleware * /) .use (/ * middleware * /) .listen (3000);
De använda sig av() funktion lägger till ett lager av middleware till programmet, och lyssna() funktionen säger att vår applikation börjar börja acceptera anslutningar på den angivna porten (3000 i det här exemplet).
Låt oss börja med något enkelt: logga. Koden för en Connect-applikation som endast använder loggverksmjukvaran är ganska enkel:
anslut () .use (connect.logger ()) .listen (3000);
Som standard analyserar noden mycket lite av den inkommande förfrågan.
Lägg till den koden i din fil och starta servern genom att köra nod server.js. Navigera till någon sökväg i din webbläsare och ignorera resultaten "Kan inte få ...". Vi är inte intresserade av vad servern skickade tillbaka till webbläsaren; Vi är intresserade av serverns logg. Titta på terminalen, och du kommer se loggen över dina önskemål. Var noga med att kolla loggdokumentationen för information om dess andra funktioner och anpassning.
Det var ett filter; Låt oss nu titta på en leverantör. Den enklaste leverantören är den statiska leverantören; Det tjänar statiska filer från en angiven mapp. Här är dess syntax:
.använd (connect.static (__ dirname + "/ public")
Du kan noga gissa syftet med Node __dirname variabel: det är sökvägen till den aktuella katalogen. Denna middleware tjänar statiskt allt från a offentlig mappen i den aktuella katalogen. Så skapa publika / page.html och lägg till en element. Starta om servern (nod server.js) och navigera till localhost: 3000 / page.html i din webbläsare. Du borde page.html gjord i webbläsaren.
Låt oss nu titta på några av Connects andra middleware-alternativ.
Som standard analyserar Node mycket lite av den inkommande förfrågan, men du kan inkludera flera olika filter för att analysera begäran om du behöver hantera mer komplexitet. Det finns fyra filter:
connect.json () analyserar JSON-förfrågan (där innehållstyp är application / json).connect.urlencoded () tolkar x-ww-form-urlencoded begäran organ.connect.multipart () tolkar multipart / form-data begäran organ.connect.bodyParser () är en genväg för att aktivera alla tre ovan.Användning av något av dessa filter ger dig möjlighet att komma åt din analyserade kropp via request.body (vi ska prata om hur man får det begäran objekt snart).
Jag tror att dessa filter är ett bra exempel på hur du finjusterar din kontroll med Connect. Du kan använda mycket lite bearbetning för att effektivisera din ansökan.
Kakor och sessioner är en viktig del av alla webbapplikationer, och det finns flera delar av middleware som hjälper till att hantera dem. De connect.cookieParser () analyserar cookies för dig, och du kan hämta cookies och deras värden via request.cookies objekt. Detta är mer användbart om du lägger till connect.session () filtrera till din app. Detta filter kräver att cookieparsern redan finns på plats. Här är ett litet exempel:
koppla () .use (connect.cookieParser ()) .use (connect.session (hemlighet: "någon hemlig text", cookie: maxAge: 30000)) .use (funktion (req, res) var sess = req.session, url = req.url.split ("/"); om (url [1] == "namn" && url [2]) sess.name = url [2]; res.end namn sparat: "+ url [2]); annars om (sess.name) res.write (" session-lagrat namn: "+ sess.name); res.end (" lagrat för en annan: "+ .cookie.maxAge / 1000) + "seconds"); else res.end ("inget lagrat namn, gå till / namn / name för att spara ett namn");). lyssna (3000); Varje middleware-funktion du skriver måste antingen skicka begäran till
Nästalager eller svara på begäran.
Efter cookieParser, vi inkluderar session filtrera och ge det två alternativ:
hemlighet skapar en signerad cookie som håller koll på sessionen.cookie.maxAge definierar sin livslängd i millisekunder; 30000 i den här koden är 30 sekunder.I finalen använda sig av() ring, vi skickar en funktion som svarar på begäran. Vi använder två egenskaper från begäran objekt: req.session för sessionsdata, och req.url för begäran URL.
Om ansökan mottar en begäran om / Namn / some_name, då lagras värdet some_name i req.session.name. Allt som lagras inom en session kan hämtas i efterföljande förfrågningar om längden på vår session. Eventuella förfrågningar gjorda för / Namn / annan ersätter sessionvariabeln, och eventuella förfrågningar till andra webbadresser matar ut värdesessionens värde och tiden som är kvar för sessionen.
Så, du kan navigera till localhost: 3000 / namn / ditt_namn, och sedan gå till localhost: 3000 att se ditt namn. Uppdatera sidan ett par gånger och titta på sekunderna räkna ner. När sessionen löper ut ser du standardmeddelandet "Inget lagrat namn".
Jag nämnde att cookieParser Filter måste komma före session.
Ordern för inkludering är viktig med middleware eftersom begäran skickas, i ordning, från lager till lager.
Därför att session Behovet av analysdata måste gälla. Förfrågan måste gå igenom cookieParser innan session.
Jag kunde förklara alla andra inbyggda delar av middleware, men jag ska bara nämna några fler innan vi skriver vår egen kod till gränssnittet med Connect.
Du lärde dig bara hur du skriver din egen kod med Connect. Här är den grundläggande syntaksen en gång till:
.använd (funktion (req, res, nästa) )
Funktionens tre parametrar är viktiga; De ger tillgång till omvärlden. De req Parametern är givetvis begäranobjektet och res är svaret. Den tredje parametern, Nästa, är nyckeln till att göra funktioner som fungerar bra i middleware stacken. Det är en funktion som skickar begäran till nästa middleware i stapeln. Se detta exempel:
connect () .use (funktion (req, res, nästa) if (req.method === 'POST') res.end ("Detta är en POST-förfrågan"); else next ) .use (funktion (req, res) res.end ("Detta är inte en POST-förfrågan (förmodligen en GET-förfrågan)");). lyssna (3000); Denna kod använder två middleware-funktioner. Den första funktionen kontrollerar förfrågan för att se om det är en POST-förfrågan. Om det är, svarar det genom att säga det. Annars ringer vi Nästa() och skicka förfrågan till nästa funktion, som svarar oavsett vad. Använda sig av ringla att testa båda skikten i terminalen:
$ curl http: // localhost: 3000 Detta är inte en POST-förfrågan (förmodligen en GET-förfrågan) $ curl -X POST http: // localhost: 3000 Detta är en POST-förfrågan
Om du inte gillar terminalen kan du prova det här användbara Chrome-plugin.
Det är viktigt att komma ihåg att varje middleware-funktion du skriver måste antingen skicka begäran till Nästa lager eller svara på begäran. Om din funktion grenar (via om uttalanden eller andra villkor) måste du se till att varje gren skickar begäran eller svarar på den. Om din app hänger i webbläsaren är det förmodligen för att du glömde att ringa Nästa() vid något tillfälle.
Nu, vad sägs om dem begäran och svar parametrar? Det här är de samma förfrågnings- och svarobjekten du får när du använder en "rå" nodserver:
kräva ("http"). skapaServer (funktion (req, res) // ...). lyssna (3000); Om du inte har använt Node server API före, låt mig visa dig vad du kan göra med det.
De begäran objektet är faktiskt en http.IncomingMessage objekt och dess viktiga egenskaper anges nedan:
req.method berättar vilken HTTP-metod som användes.req.url berättar vilken webbadress som begärdes.req.headers är ett objekt med rubrikens namn och värden.req.query är ett objekt med data i en frågesträng (för att analysera det, behöver du connect.query () middleware på plats).req.body är ett föremål för formulärdata (du behöver lite kroppsparsning av middleware på plats).req.cookies är ett föremål för cookiedata (kräver kakparsning).req.session är ett föremål för sessionen data (igen, du behöver cookie parsing och session middleware på plats)Du kan se allt detta på jobbet med följande kod:
connect () .use (connect.query ()) // ger oss req.query .use (connect.bodyParser ()) // ger oss req.body .use (connect.cookieParser ()) // för session .use (connect.session (secret: "asdf")) // ger oss req.session .use (funktion (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 ();). Lyssna (3000); För att se något för var och en av dessa värden måste du lägga in vissa data till en webbadress med en frågesträng. Följande bör vara tillräckligt:
curl -X POST -d "name = YourName" "http: // localhost: 3000 / some / url? some = data"
Med de sju egenskaperna kan du hantera nästan alla förfrågningar du får. Jag tror inte att släpvagnar används ofta (jag har aldrig sett dem i min erfarenhet), men du kan använda req.trailers om du förväntar dig dem i dina önskemål (trailers är precis som rubriker, men efter kroppen).
Så, vad sägs om ditt svar?
Det raka svarobjektet ger inte den lyx som biblioteken (som Express) ger dig. Du kan till exempel inte svara med ett enkelt återkopplingssamtal till en färdiggjord mall - åtminstone, inte som standard. Mycket lite antas i svaret, så du måste fylla i alla små detaljer.
Vi börjar med statuskoden och svarhuvudena. Du kan ställa in alla på en gång med hjälp av writeHead () metod. Här är ett exempel från Node-dokumenten:
var kropp = "hej värld"; response.writeHead (200, 'Innehållslängd': body.length, 'Content-Type': 'text / plain');
Om du vill sätta upp rubriker individuellt kan du använda setHeader () metod:
connect () .use (funktion (req, res) var acceptera = req.headers.accept.split (","), body, typ; console.log (acceptera); om (accept.indexOf ("application / json ")> -1) typ =" application / json "; body = JSON.stringify (message:" hej "); annars om (accept.indexOf (" text / html ")> -1) typ = "text / html"; body = " Hej!
"; else type =" text / plain "; body =" hej! "; res.statusCode = 200; res.setHeader (" Content-Type ", typ); res.end (body);). lyssna (3000); Lägg till den här koden i en fil, starta servern och fråga den från webbläsaren. Du har HTML! Kör nu:
curl http: // localhost: 3000
Och du får vanlig text. För JSON, försök här:
curl -H "acceptera: application / json" http: // localhost: 3000
Allt från samma webbadress!
Använda sig av res.getHeader (namn) om du behöver veta vilka rubriker som redan har ställts in. Tou kan också använda res.removeHeader (namn) för att ta bort en rubrik.
Naturligtvis är ett svar värdelöst utan en kropp. Som du har sett i hela denna handledning kan du skriva bitar av data till kroppen med res.write () metod. Detta accepterar ett sträng- eller buffertobjekt som ett argument. Om det är en sträng är den andra parametern kodningstypen (den är som standard utf8).
De skicka igen() Metoden stänger kroppen, men du kan skicka data till den för att skriva till responsflödet. Detta är användbart i situationer där du bara behöver skriva ut en enda rad.
Det är lite svårt att svara med större HTML-kroppar i vanlig gammal nod och anslutning. Detta är ett bra ställe att kasta tredjeparts middleware i mixen. Du kan hitta en lista över middleware från tredje part på Connect Github wiki. Som ett exempel kommer vi att använda Connect-Jade-paketet, vilket gör att vi kan göra jade-visningar.
Först installera anslut-jade:
npm installera connect-jade
Därefter behöver du och lägg till den som middleware. Du vill ange några standardvärden:
var connect = kräver ("anslut"), connectJade = kräver ("connect-jade"); ansluta () .use (connectJade (root: __dirname + "/ views), standardvärden: title:" MyApp ")) använd (funktion (req, res) res.render (" index " : "Välkommen till min app");). Lyssna (3000); Ställ in roten som den katalog som innehåller visningsfilerna. Du kan också ställa in defaults; Dessa är variabler som är tillgängliga inom varje syn, såvida vi inte åsidosätter dem senare när du ringer göra().
Den sista funktionen i denna kod ringer till res.render (). Denna metod tillhandahålls av anslut-jade paket.
Det första argumentet som det accepterar är namnet på visningen att göra.
Det är vägen till vyn, sans sökvägen som vi definierade när du lägger till middleware, sans jade filtillägget. För den här koden behöver vi en visningar / index.jade mall att göra. Vi kommer att hålla det enkelt:
html huvud titel = titel kropp h1 = rubrik
Om du inte är bekant med jade lägger vi in taggnamn för att skapa en HTML-struktur. Liknande tecken hämtar värdet av en JavaScript-variabel. Dessa variabler kommer från defaults vi satt upp, plus det (valfria) andra parameterobjektet som passerade till res.render ().
Det finns många andra tredjeparts middleware, men de fungerar som varandra. Du installerar dem via npm, kräver dem och sätter dem i aktion.
Om du gräver hur Connect fungerar, kommer du att upptäcka att varje lager är en nodmodul - en mycket intelligent design. Om du använder Anslut för stora applikationer skulle det vara perfekt att skriva din kod i nodmodulformat. Du kanske har en app.js filen så här:
// app.js module.exports = funktion (req, res, next) res.end ("detta kommer från en modul"); ; Och i din server.js:
var connect = kräver ("anslut"), app = kräver ("./ app"); anslut () .use (app) .listen (3000); Om du vill ha ett nybörjarevänligt bibliotek som gör det enkelt att bygga stora webbapps, är Connect inte din lösning. Anslutningen är tänkt att vara ett tunt lager ovanpå det råa nod-API som ger dig fullständig kontroll över din serverns applikation. Om du vill ha lite mer, rekommenderar jag Express (av samma personer, förresten). Annars är Connect ett fantastiskt, utökbart bibliotek för Node-webbapplikationer.
