Notes d'étude NodeJS Connecter le module middleware (2)_node.js

1, analyse d'ouverture

Bonjour à tous, l'article d'aujourd'hui concerne principalement une série d'analyses de code source sur le middleware "Connect" et les middlewares auxiliaires associés. Je pense que vous avez également lu l'article précédent,

.

Présente l'utilisation et le but, et cet article est également dans mon propre intérêt, afin que les lecteurs puissent en avoir une compréhension plus approfondie. S'il y a quelque chose d'incorrect dans la phase d'analyse, veuillez me donner quelques conseils,

.

D'accord ! Comme d’habitude, allons droit au but. Regardons d'abord un exemple, combiné à une analyse d'introduction, comme suit :

Copier le code Le code est le suivant :

var connect = require("./lib/connect") ;
var app = connect.createServer() ;
app.use(connect.static(__dirname "/public",{
Âge max : 0
})) ;
app.use(function(req,res,next){
res.end("Bonjour tout le monde !") ;
})
.écouter(8888) ;

Deuxièmement, analyse ligne par ligne :

(1), la première ligne, introduit le module "connect", crée un serveur http|https via connect et fournit toutes les fonctions du serveur http.

Le middleware "connect" permet de créer des "serveurs" de diverses manières,

Copier le code Le code est le suivant :

var serveur = connect.createServer(
Connect.logger()
, connect.static(__dirname '/public')
) ; // 1
var app = connecter() ;
app.use (fonction (req, res) {
res.end("Bonjour, Nobita!n") ;
}).écouter(8888) ; // 2

Alors comment ça se passe ? Voir le code source :

Copier le code Le code est le suivant :

exports = module.exports = createServer ;
exports.createServer = createServer ;

Montez "createServer" sur les "exports" globaux, puis étendez un attribut "createServer" et montez-le à nouveau. Le but est d'être compatible avec la forme d'écriture native,

.

Atteindre l'objectif de créer de différentes manières. C’est aussi une idée dont chacun peut s’inspirer dans son développement quotidien.

(2) Regardons la deuxième ligne "connect.createServer" et voyons ce qu'elle fait. Voir le code source suivant :

Copier le code Le code est le suivant :

var HTTPServer = require('./http').Server ,
HTTPSServer = require('./https').Server ;
fonction createServer() {
if ('object' == type d'arguments[0]) {
Renvoie le nouveau HTTPSServer(arguments[0], Array.prototype.slice.call(arguments, 1));
} autre {
Renvoie le nouveau HTTPServer(Array.prototype.slice.call(arguments));
>
};

"HTTPSServer" et "HTTPServer" sont fondamentalement identiques, sauf que "HTTPSServer" encapsule la méthode https. Lorsque "createServer", vous pouvez également transmettre une série de middleware, ce qui a le même effet que l'introduction suivante, mais il ne peut être lié qu'au répertoire racine.

(3), continuez à regarder la troisième ligne "app.use()", ce qui est fait, regardez le code source suivant :

Copier le code Le code est le suivant :

var Server = exports.Server = function HTTPServer (middleware) {
This.stack = [];
middleware.forEach(function(fn){
This.use(fn);
}, ceci);
http.Server.call(this, this.handle);
};
/**
  * Hériter de `http.Server.prototype`.
 */
Serveur.prototype.__proto__ = http.Serveur.prototype;

"connect" est un prototype hérité du "serveur http", il remplacera le requestListener du serveur par le middleware utilisé.

Utilisez "connect.use(route, handle)" pour ajouter un middleware à chaque route. Ces "handles" de middleware seront liés à "route" et stockés dans une "pile", à chaque fois qu'il y aura une "demande". demandé,

Parcourez ce tas, trouvez le "handle" correspondant à "route" et exécutez "handle". Si "handle" appelle finalement "next()", il continuera à trouver et exécuter le prochain "handle" correspondant.

En encapsulant "handle", il est facile d'ajouter plus de "middleware" basé sur "connect".

(4), enfin jetez un oeil à "listen(8888)", ça fait quoi ?

C'est très simple. En héritant de l'objet Serveur sous-jacent, on lui donne la fonction "écouter" pour écouter sur un port spécifique.

　Serveur.prototype.__proto__ = http.Serveur.prototype

Voici l'intégralité du code source de "connect.js". Afin d'économiser de l'espace, tous les commentaires ont été supprimés, comme indiqué ci-dessous :

Juste pour ajouter :

Copier le code Le code est le suivant :

fs.readdirSync(__dirname '/middleware').forEach(function(filename){
if (/.js$/.test(filename)) {
var nom = filename.substr(0, filename.lastIndexOf('.'));
exports.middleware.__defineGetter__(nom, fonction(){
         return require('./middleware/' name);
});
>
});

"Exporte" l'objet "middleware", puis définit en boucle une méthode pour l'objet "middleware". Cette méthode consiste à charger directement le module de fichier .js dans le dossier "middleware".

Utilisation : "exports.utils.merge(exports, exports.middleware)" Cette phrase exporte directement les méthodes en middleware.

Trois, pour résumer :

(1) Comprendre l'intention de conception du code source aidera à maximiser les gains d'application.

(2) Lorsque vous regardez le code source, comprenez le processus avant de prêter attention aux détails grammaticaux.

(3), apprenez des idées d'implémentation intelligentes dans le code source, mais ne sur-concevez pas, concevez pour le plaisir de concevoir.

(4), nous continuerons à analyser le middleware associé demain et continuerons à le mettre à jour. . . . . .