Une analyse approfondie du « modèle oignon » dans Nodejs

Cet article vous fera découvrir le "modèle oignon" dans Nodejs. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Les frameworks Node.js actuellement populaires incluent Express, KOA et Egg.js, suivis par un autre framework émergent lié à TypeScript - Nest.js, quel que soit Node.js. qu'il s'agit d'un framework, il est implémenté sur la base d'un middleware, et la méthode d'exécution du middleware (peut être comprise comme une classe ou un module de fonction) doit être basée sur le modèle oignon

Apprentissage recommandé : "nodejs tutoriel》

1. Modèle d'oignon

Nous savons tous que les oignons sont enveloppés une couche à la fois, couche par couche, mais maintenant nous ne regardons pas sa structure tridimensionnelle , mais il faut couper l'oignon à partir du plan de coupe, comme indiqué sur la photo :

Vous pouvez voir cela afin de passer par le centre de l'oignon. , vous devez d'abord pénétrer la peau de l'oignon couche par couche jusqu'au point central, puis la peau est pénétrée vers l'extérieur couche par couche à partir du point central. Il y a une caractéristique ici : combien de couches de peau sont pénétrées lors de l'entrée, combien. les couches de peau doivent être pénétrées à la sortie. Pénétrer d’abord dans l’épiderme puis en sortir est conforme au principe de ce que l’on appelle une liste de pile, premier entré, dernier sorti.

2. La relation entre le modèle onion et Node

Les frameworks Node.js les plus populaires incluent actuellement Express, KOA et Egg.js. Quel que soit le framework Node.js dont il s'agit. est basé sur un middleware Pour y parvenir, la méthode d'exécution du middleware (peut être comprise comme une classe ou un module de fonction) doit être basée sur le modèle de l'oignon

Nous pouvons considérer la peau de l'oignon comme un middleware :

Le processus de l'extérieur vers l'intérieur est le mot-clé next();

, tandis que de l'intérieur vers l'extérieur est qu'après l'exécution de chaque middleware, il entre dans la couche supérieure d'origine du middleware, jusqu'au bout. à la couche la plus externe.

3. Exécution du middleware

En prenant express comme exemple, voici un processus d'exécution de base du middleware :

,

Koa est un framework de nœuds de nouvelle génération développé par la même équipe basé sur Express. La principale différence entre les deux est :

• Express encapsule et possède de nombreux middleware intégrés. , comme connect et router, tandis que KOA est relativement léger et que les développeurs peuvent personnaliser le framework en fonction de leurs propres besoins
• Express est basé sur un rappel pour traiter le middleware, tandis que KOA est basé sur wait/async
• Lors de l'exécution d'un middleware de manière asynchrone, Express ne suit pas strictement le modèle d'oignon pour exécuter le middleware, mais KOA le suit strictement (reflétant que les deux processus seront différents lorsque le middleware est une fonction asynchrone).

Introduction aux différences entre Express et KOA concernant la façon dont le modèle d'oignon est exécuté  :

Nous

gardons les trois originaux des ci-dessus l'exemple de middleware de code, et insérez un nouveau middleware asynchrone entre 2 et 3. Le code est le suivant :

(1) express

/**
 * 异步中间件
 */
app.use(async (req, res, next) => {
    console.log('async');
    await next();
    await new Promise(
        (resolve) => 
            setTimeout(
                () => {
                    console.log(`wait 1000 ms end`);
                    resolve()
                }, 
            1000
        )
    );
    console.log('async end');
});

puis D'autres middlewares sont modifiés pour attendre la méthode next(), comme indiqué dans la méthode middleware 1 suivante :

/**
 * 中间件 1
 */
app.use(async (req, res, next) => {
    console.log('first');
    await next();
    console.log('first end');
});

Réexécutez, le résultat final est :

Vous pouvez voir qu'il est normal d'aller de l'extérieur vers l'intérieur, et les appels sont effectués couche par couche. Lorsque l'on passe de l'intérieur vers l'extérieur, certains changements se produisent, la raison principale est que le middleware asynchrone ne produit pas le résultat. résultats d'exécution dans l'ordre

.

(2) Koa

Conservez la séquence de code ci-dessus et modifiez uniquement la syntaxe express correspondante en syntaxe koa Les parties du code du middleware 1 et du middleware asynchrone sont les suivantes :

const Koa = require('koa');
const app = new Koa();
/**
 * 中间件 1
 */
app.use(async (ctx, next) => {
    console.log('first');
    await next();
    console.log('first end');
});
/**
 * 异步中间件
 */
app.use(async (ctx, next) => {
    console.log('async');
    await next();
    await new Promise(
        (resolve) => 
            setTimeout(
                () => {
                    console.log(`wait 1000 ms end`);
                    resolve()
                }, 
            1000
        )
    );
    console.log('async end');
});

Rerun, le résultat final est :

Vous constaterez que KOA suit strictement l'exécution du modèle d'oignon, de haut en bas, que est, de l'intérieur de l'oignon vers l'extérieur, la sortie en premier, la deuxième, asynchrone et la troisième, puis la troisième extrémité, l'extrémité asynchrone, la deuxième extrémité et la première extrémité de l'intérieur vers l'extérieur.

Pour plus de connaissances liées à la programmation, veuillez visiter :

Enseignement de la programmation

 ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!