Share
Les nouveaux arrivants sur NodeJS ont généralement du mal à comprendre son API. Heureusement, de nombreux développeurs ont créé des frameworks facilitant l'utilisation de Node. Connect est l'un de ces cadres. Il se situe au-dessus de l'API du nœud et trace la ligne entre confort et contrôle.
Pensez à Connect comme une pile de middleware. À chaque requête, Connect filtre à travers les couches de middleware, chacune ayant la possibilité de traiter la requête HTTP. Quand T.J. Holowaychuk a annoncé Connect, il a dit qu'il y avait deux types de middleware. Le premier est un filtre.
Les filtres traitent la demande, mais ils ne répondent pas (pensez à la journalisation du serveur).
L'autre type est un fournisseur, qui répond à la demande. Vous pouvez incorporer autant de couches de middleware que vous le souhaitez. la requête traverse chaque couche jusqu'à ce que l'un des middlewares réponde à la requête.
Tout d’abord, vous devez installer le package Connect via npm:
npm install connect
Maintenant, créez un server.js fichier et ajoutez le code suivant:
Accentsconagua
var connect = require ("connect"); le relier variable est une fonction qui renvoie une nouvelle application Connect. Notre prochaine étape consiste donc à créer cette application:
var app = connect ();
Vous n'avez pas besoin de créer un app variable pour la plupart de vos applications. Les fonctions impliquées dans la création d’une application (relier() et utilisation()) sont chaînables:
connect () .use (/ * middleware * /) .use (/ * middleware * /) .listen (3000);
le utilisation() fonction ajoute une couche de middleware à l'application, et le écouter () fonction indique à notre application de commencer à accepter les connexions sur le port spécifié (3000 dans cet exemple).
Commençons par quelque chose de simple: la journalisation. Le code d'une application Connect utilisant uniquement le middleware de journalisation est plutôt simple:
connect () .use (connect.logger ()) .listen (3000);
Par défaut, le noeud analyse très peu de la demande entrante.
Ajoutez ce code à votre fichier et démarrez le serveur en lançant noeud serveur.js. Naviguez vers n'importe quel chemin dans votre navigateur et ignorez les résultats "Impossible d'obtenir ...". Nous ne sommes pas intéressés par ce que le serveur a renvoyé au navigateur. nous sommes intéressés par le journal du serveur. Regardez le terminal et vous verrez le journal de vos demandes. N'oubliez pas de consulter la documentation de l'enregistreur pour plus d'informations sur ses autres fonctionnalités et sa personnalisation..
C'était un filtre. Maintenant, regardons un fournisseur. Le fournisseur le plus simple est le fournisseur statique. il sert des fichiers statiques à partir d'un dossier spécifié. Voici sa syntaxe:
.use (connect.static (__ dirname + "/ public")
Vous pouvez probablement deviner le but de Node __dirname variable: c'est le chemin du répertoire en cours. Ce middleware sert statiquement quoi que ce soit d'un Publique dossier dans le répertoire en cours. Alors, créez public / page.html et ajouter un élément. Redémarrez le serveur (noeud serveur.js) et accédez à localhost: 3000 / page.html dans votre navigateur. Vous devriez page.html rendu dans le navigateur.
Voyons maintenant quelques-unes des autres options de middleware de Connect.
Par défaut, Node analyse très peu de la demande entrante, mais vous pouvez incorporer plusieurs filtres différents pour analyser la demande si vous devez gérer plus de complexité. Il y a quatre filtres:
connect.json () analyse les corps de requête JSON (où le type de contenu est application / json).connect.urlencoded () analyse x-ww-form-urlencoded corps de la demande.connect.multipart () analyse multipart / form-data corps de la demande.connect.bodyParser () est un raccourci pour activer tous les trois ci-dessus.L'utilisation de l'un de ces filtres vous donne la possibilité d'accéder à votre corps analysé via request.body (nous parlerons de comment l'obtenir demande objet bientôt).
Je pense que ces filtres sont un bon exemple de la manière d'affiner votre contrôle avec Connect. Vous pouvez utiliser très peu de traitement afin de rationaliser votre application.
Les cookies et les sessions constituent une partie importante de toute application Web, et plusieurs middleware facilitent leur gestion. le connect.cookieParser () analyse les cookies pour vous et vous pouvez récupérer les cookies et leurs valeurs via le bouton demande.cookies objet. Ceci est plus utile si vous ajoutez le connect.session () filtrer à votre application. Ce filtre nécessite que l'analyseur de cookie soit déjà en place. Voici un petit exemple:
connect () .use (connect.cookieParser ()) .use (connect.session (secret: 'un texte secret', cookie: maxAge: 30000))) .use (function (req, res) var sess = req.session, url = req.url.split ("/"); if (url [1] == "nom" && url [2]) sess.name = url [2]; res.end (" nom enregistré: "+ url [2]); else if (sess.name) res.write (" nom stocké dans la session: "+ sess.name); res.end (" stocké pour un autre: "+ (sess .cookie.maxAge / 1000) + "secondes"); else res.end ("pas de nom enregistré; accédez à / nom / nom pour enregistrer un nom");). listen (3000); Chaque fonction middleware que vous écrivez doit soit transmettre la demande au
suivantsuperposer ou répondre à la demande.
Après le cookieParser, nous incluons le session filtrer et passer deux options:
secret crée un cookie signé qui garde la trace de la session.cookie.maxAge définit sa durée de vie en millisecondes; le 30000 dans ce code est de 30 secondes.Dans la finale utilisation() appel, nous passons une fonction qui répond à la demande. Nous utilisons deux propriétés de la demande objet: req.session pour les données de session, et req.url pour l'URL de la demande.
Si la demande reçoit une demande de / nom / nom_comme, alors il stocke la valeur un_nom dans req.session.name. Tout ce qui est stocké dans une session peut être récupéré dans les demandes ultérieures pour la durée de notre session. Toutes les demandes faites pour / nom / autre remplace la variable de session et toutes les demandes adressées à d'autres URL génèrent la valeur de la variable de session et le temps restant pour la session..
Donc, vous pouvez naviguer vers localhost: 3000 / name / your_name, et puis aller à localhost: 3000 à voir votre nom. Actualisez la page plusieurs fois et observez le compte à rebours des secondes. À l'expiration de la session, le message par défaut "Pas de nom stocké" s'affiche..
J'ai mentionné que le cookieParser le filtre doit venir avant session.
L'ordre d'inclusion est important avec le middleware car la requête est passée, dans l'ordre, d'une couche à l'autre..
Parce que session a besoin des données du cookie analysé, la requête doit passer par cookieParser avant session.
Je pourrais expliquer tous les autres middleware intégrés, mais je n'en mentionnerai que quelques-uns avant d'écrire notre propre code pour l'interface avec Connect.
Vous venez d'apprendre à écrire votre propre code avec Connect. Voici à nouveau la syntaxe de base:
.use (fonction (req, res, next) )
Les trois paramètres de la fonction sont importants. ils donnent accès au monde extérieur. le req paramètre est, bien sûr, l'objet de demande, et res est la réponse. Le troisième paramètre, suivant, est la clé pour créer des fonctions qui fonctionnent bien dans la pile de middleware. C'est une fonction qui transmet la requête au middleware suivant dans la pile. Voir cet exemple:
connect () .use (fonction (req, res, next) if (req.method === 'POST') res.end ("Ceci est une requête POST"); else next (); ) .use (function (req, res) res.end ("Ce n'est pas une requête POST (probablement une requête GET)");). listen (3000); Ce code utilise deux fonctions middleware. La première fonction vérifie la méthode de requête pour voir s’il s’agit d’une requête POST. Si c'est le cas, il répond en le disant. Sinon, nous appelons suivant() et passez la requête à la fonction suivante, qui répond quoi qu'il arrive. Utilisation boucle pour tester les deux couches du terminal:
$ curl http: // localhost: 3000 Ceci n'est pas une demande POST (probablement une demande GET) $ curl -X POST http: // localhost: 3000 Ceci est une demande POST
Si vous n'aimez pas le terminal, essayez ce plugin Chrome utile.
Il est important de se rappeler que chaque fonction middleware que vous écrivez doit soit transmettre la demande au suivant couche ou répondre à la demande. Si votre fonction se branche (via des déclarations if ou d’autres conditions), vous devez vous assurer que chaque branche transmet la demande ou y répond. Si votre application se bloque dans le navigateur, c'est probablement parce que vous avez oublié d'appeler suivant() à un moment donné.
Maintenant, qu'en est-il de ceux demande et réponse paramètres? Ce sont les mêmes objets de requête et de réponse que vous recevez lorsque vous utilisez un serveur de nœud "brut":
require ("http"). createServer (fonction (req, res) //…). listen (3000); Si vous n'avez pas encore utilisé l'API du serveur de Node, laissez-moi vous montrer ce que vous pouvez en faire..
le demande l'objet est en fait un http.IncomingMessage objet, et ses propriétés importantes sont listées ci-dessous ::
méthode requise vous indique quelle méthode HTTP a été utilisée.req.url vous indique quelle URL a été demandée.req.headers est un objet avec les noms d'en-tête et les valeurs.req.query est un objet contenant des données dans une chaîne de requête (pour analyser cela, vous aurez besoin de la connect.query () middleware en place).req.body est un objet des données de formulaire (vous aurez besoin d'un middleware d'analyse corporelle sur place).req.cookies est un objet des données de cookie (nécessite l'analyse du cookie).req.session est un objet des données de session (encore une fois, vous aurez besoin de l'analyse des cookies et du middleware de session en place)Vous pouvez voir tout cela au travail avec le code suivant:
connect () .use (connect.query ()) // nous donne req.query .use (connect.bodyParser ()) // nous donne req.body .use (connect.cookieParser ()) // pour la session .use (connect.session (secret: "asdf")) // nous donne req.session .use (fonction (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 ();). Listen (3000); Pour voir quelque chose pour chacune de ces valeurs, vous devez envoyer des données à une URL avec une chaîne de requête. Ce qui suit devrait suffire:
curl -X POST -d "name = YourName" "http: // localhost: 3000 / some / url? some = data"
Avec ces sept propriétés, vous pouvez gérer à peu près toutes les demandes que vous recevrez. Je ne pense pas que les remorques soient utilisées souvent (je ne les ai jamais vues auparavant), mais vous pouvez utiliser req.trailers si vous les attendez dans vos demandes (les bandes-annonces sont comme des en-têtes, mais après le corps).
Alors, qu'en est-il de votre réponse?
L'objet de réponse brut ne fournit pas le luxe que vous offrent les bibliothèques (comme Express). Par exemple, vous ne pouvez pas répondre par un simple appel de rendu à un modèle prédéfini, du moins, pas par défaut. On suppose très peu dans la réponse, vous devez donc remplir tous les petits détails..
Nous allons commencer par le code d'état et les en-têtes de réponse. Vous pouvez les régler tous en même temps en utilisant le bouton writeHead () méthode. Voici un exemple tiré de la documentation sur les nœuds:
var body = 'bonjour le monde'; response.writeHead (200, 'Content-Length': body.length, 'Content-Type': 'text / plain');
Si vous avez besoin de définir individuellement des en-têtes, vous pouvez utiliser la commande setHeader () méthode:
connect () .use (fonction (req, res) var accept = req.headers.accept.split (","), corps, type; console.log (accept); if (accept.indexOf ("application / json ")> -1) type =" application / json "; body = JSON.stringify (message:" hello "); else if (accept.indexOf (" text / html ")> -1) type = "text / html"; body = " Bonjour!
"; else type =" text / plain "; body =" hello! "; res.statusCode = 200; res.setHeader (" Content-Type ", type); res.end (body);). écouter (3000); Ajoutez ce code à un fichier, démarrez le serveur et demandez-le au navigateur. Vous avez HTML! Maintenant, lancez:
curl http: // localhost: 3000
Et vous recevrez un texte en clair. Pour JSON, essayez ceci:
curl -H "accepter: application / json" http: // localhost: 3000
Tous de la même URL!
Utilisation res.getHeader (nom) si vous avez besoin de savoir quels en-têtes ont déjà été définis. Vous pouvez également utiliser res.removeHeader (name) supprimer un en-tête.
Bien sûr, une réponse est inutile sans corps. Comme vous l'avez vu tout au long de ce didacticiel, vous pouvez écrire des morceaux de données dans le corps à l'aide du res.write () méthode. Ceci accepte une chaîne ou un objet tampon comme argument. S'il s'agit d'une chaîne, le second paramètre est le type d'encodage (sa valeur par défaut est utf8).
le res.end () méthode ferme le corps, mais vous pouvez lui transmettre des données pour écrire dans le flux de réponses. Ceci est utile dans les situations où vous n'avez besoin que de produire une seule ligne..
Il est quelque peu difficile de répondre avec des corps HTML plus volumineux dans Node and Connect. C’est un bon endroit pour ajouter un middleware tiers. Vous pouvez trouver une liste des intergiciels tiers sur le wiki Connect Github. Par exemple, nous allons utiliser le paquet connect-jade, qui nous permet de rendre des vues jade.
Tout d'abord, installez connect-jade:
npm installer connect-jade
Ensuite, exigez et ajoutez-le en tant que middleware. Vous voudrez définir quelques valeurs par défaut:
var connect = require ("connect"), connectJade = require ("connect-jade"); connect () .use (connectJade (root: __dirname + "/ views", par défaut: title: "MyApp")) .use (fonction (req, res) res.render ("index", entête : "Bienvenue dans mon application");). Listen (3000); Définissez la racine comme répertoire contenant les fichiers de vue. Vous pouvez également définir défauts; ce sont des variables disponibles dans chaque vue, à moins que nous ne les remplacions plus tard lors de l'appel rendre().
La dernière fonction de ce code fait un appel à res.render (). Cette méthode est fournie par le connect-jade paquet.
Le premier argument accepté est le nom de la vue à rendre.
C'est le chemin de la vue, sans le chemin que nous avons défini lors de l'ajout du middleware, sans l'extension de fichier jade. Pour ce code, nous avons besoin d'un views / index.jade modèle à rendre. Nous allons garder les choses simples:
titre de tête html = corps du titre h1 = titre
Si vous n'êtes pas familier avec jade, nous indentons les noms de balises pour créer une structure HTML. Le signe égal récupère la valeur d'une variable JavaScript. Ces variables proviennent de la défauts nous mettons en place, plus le deuxième objet paramètre (facultatif) passé à res.render ().
Il existe de nombreux autres middlewares tiers, mais ils fonctionnent de manière similaire. Vous les installez via npm, vous en avez besoin et vous les mettez en action.
Si vous explorez le fonctionnement de Connect, vous constaterez que chaque couche est en fait un module de nœud, une conception très intelligente. Si vous utilisez Connect pour des applications volumineuses, il serait idéal d'écrire votre code au format de module de nœud. Vous pourriez avoir un app.js fichier comme ceci:
// app.js module.exports = function (req, res, next) res.end ("cela provient d'un module"); ; Et dans ton server.js:
var connect = require ("connect"), app = require ("./ app"); connect () .use (app) .listen (3000); Si vous souhaitez une bibliothèque conviviale pour les débutants facilitant la création d'applications Web volumineuses, Connect n'est pas votre solution. Connect est censé être une couche mince au-dessus de l'API de nœud brute qui vous donne un contrôle complet sur votre application serveur. Si vous voulez un peu plus, je recommande Express (par les mêmes personnes, d'ailleurs). Sinon, Connect est une fantastique bibliothèque extensible pour les applications Web Node..
