Guide de développement du guide

Qu'est-ce que fibjs?

fibjs est un cadre de développement de serveur d'applications conçu principalement pour le développement de back-end Web. Il est basé sur le moteur JavaScript de Google v8 et sélectionne une solution de concurrence différente du rappel traditionnel. Fibjs utilise la fibre pour isoler la complexité métier causée par les appels asynchrones au niveau de la couche de structure, ce qui réduit considérablement les difficultés de développement et les problèmes de performances causés par le traitement asynchrone fréquent dans l'espace utilisateur.

Pour des raisons historiques, JavaScript est principalement utilisé pour le traitement de l'interface utilisateur dans les navigateurs. Le développement de l'interface utilisateur est un modèle piloté par événement à fil unique, de sorte que JavaScript a également formé le traitement asynchrone comme paradigme de programmation principal.

Avec le succès de JavaScript, de plus en plus de personnes ont commencé à appliquer JavaScript à d'autres scénarios. Dans le même temps, les gens découvrent de plus en plus que le traitement asynchrone n'est pas l'option la plus appropriée dans de nombreux scénarios.

Retour au développement original et agile

Fibjs utilise la fibre au niveau de la couche de structure pour isoler la complexité métier causée par les appels asynchrones et encapsule le traitement asynchrone de io dans un appel synchrone plus intuitif. Les ingénieurs ont seulement besoin d'écrire du code selon la logique métier synchrone habituelle pour profiter du traitement asynchrone. Grande commodité.

Le code suivant est extrait de la documentation du module mysql:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
conn.beginTransaction(err => { if (err) { throw err; } conn.query('INSERT INTO posts SET title=?', title, (error, results, fields) => { if (error) { return conn.rollback(() => { throw error; }); } var log = 'Post ' + results.insertId + ' added'; conn.query('INSERT INTO log SET data=?', log, (error, results, fields) => { if (error) { return conn.rollback(() => { throw error; }); } conn.commit((err) => { if (err) { return conn.rollback(() => { throw err; }); } console.log('success!'); }); }); }); });

Dans fibjs, pour terminer le même travail, le code est le suivant:

1 2 3 4 5 6
conn.trans(() => { var result = conn.execute('INSERT INTO posts SET title=?', title); var log = 'Post ' + results.insertId + ' added'; conn.execute('INSERT INTO log SET data=?', log); }); console.log('success!');

Si vous recherchez la simplicité, vous pouvez même écrire du code comme ceci:

1 2 3 4
conn.trans(() => conn.execute('INSERT INTO log SET data=?', 'Post ' + conn.execute('INSERT INTO posts SET title=?', title).insertId + ' added')); console.log('success!');

Nous pouvons clairement comparer les différences apportées par deux styles de programmation différents. Moins de code conduit à moins d'erreurs et à mesure que le code diminue, la logique du code devient plus claire, qu'il s'agisse de développement ou de maintenance, il en bénéficiera.

Embrassez la haute énergie

Bien que nous puissions facilement augmenter la vitesse de réponse en étendant le serveur, les performances devraient toujours être l'une des bases importantes pour choisir un cadre de développement. Avec l'introduction d'ES7, async a été introduit dans JavaScript en tant que nouveau modèle de développement asynchrone. Cependant, lorsque nous apprécions le style de synchronisation apporté par async, nous devons également faire face à son impact sur les performances.

Nous pouvons utiliser un morceau de code de test pour comparer les différences de performances apportées par différents styles de programmation:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
var count = 1000; async function test_async(n) { if (n == count) return; await test_async(n + 1); } function test_callback(n, cb) { if (n == count) return cb(); test_callback(n + 1, () => { cb(); }); } function test_sync(n) { if (n == count) return; test_sync(n + 1); } async function test() { console.time("async"); await test_async(0); console.timeEnd("async"); console.time("callback"); test_callback(0, () => { console.timeEnd("callback"); }); console.time("sync"); test_sync(0); console.timeEnd("sync"); } test();

Sous la dernière v8 v6.7.192, les résultats de cette exécution de code sont les suivants:

1 2 3
async: 5.276ms callback: 0.117ms sync: 0.038ms

Nous pouvons clairement savoir à partir des résultats des tests que lorsque async est largement utilisé dans le projet, le serveur passera beaucoup de temps à traiter l'appel et le retour de la fonction async. Nous l'avons également constaté lors des tests réels de certaines applications serveur. Et cette forte baisse des performances est totalement inacceptable.

Étant donné que fibjs utilise la fibre, il peut tirer pleinement parti des caractéristiques du langage JavaScript lui-même et maximiser les performances supérieures de la v8. Les ingénieurs peuvent facilement maximiser les performances du serveur.

Choix flexible de paradigme sans être kidnappé

Choisir d'utiliser fibjs ne signifie pas que vous devez utiliser un style de développement synchrone. En fait, fibjs prend en charge tout paradigme de programmation asynchrone que vous avez vu et peut basculer de manière flexible entre style synchrone et style asynchrone.

Qu'il s'agisse de rappel ou d'async, il y a une faille fatale, qui est contagieuse. Tant qu'une fonction est de rappel ou asynchrone, toutes les autres fonctions qui en dépendent doivent être de rappel ou asynchrone. Cela entraînera d'énormes coûts de développement dans le développement de logiciels à grande échelle.

Prenons un scénario de développement de serveur simple comme exemple. Au début du projet, nous avons choisi la mémoire comme stockage des données de session. À ce stade, nous pouvons utiliser la synchronisation pour lire et stocker directement les données, et développer une entreprise complète sur cette base. Avec le développement de l'échelle de l'entreprise, nous devons stocker les données de session dans redis ou mongodb. À ce stade, nous devons modifier les opérations liées à la session en mode asynchrone.

En théorie, nous pouvons modifier tour à tour chaque fonction pour la rendre conforme aux exigences de la fonction dont elle dépend, mais cela nous oblige à bien comprendre tous les modules et à pouvoir les modifier. Ceci est totalement impossible lors de l'utilisation du développement collaboratif multi-personnes ou lors de l'utilisation de modules tiers.

Par conséquent, tous les modules courants doivent fournir des interfaces de synchronisation et d'async pour équilibrer l'équilibre entre asynchrone et performances. Les développeurs plus ordinaires choisiront de fournir uniquement une interface asynchrone. Ce qui provoque un désastre de performance.

Dans fibjs, vous pouvez facilement résoudre des problèmes similaires et éviter les infections explicites asynchrones et non contrôlées:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
var util = require('util'); function session_get(sid) { return sdata; } async function async_session_get(sid) { return sdata; } function callback_session_get(sid, cb) { cb(null, sdata); } data = session_get(sid); data = util.sync(async_session_get)(sid); data = util.sync(callback_session_get)(sid);

fibjs peut utiliser util.sync pour transformer les fonctions de rappel ou asynchrones en fonctions de synchronisation et les appeler directement. De cette façon, nous pouvons facilement intégrer des modules de différents paradigmes de programmation et les transformer en paradigmes de synchronisation à un coût de développement minimal, évitant efficacement les catastrophes causées par l'infection de paradigmes.

Commencez à expérimenter

Êtes-vous prêt à commencer une expérience de développement agréable? Commencez donc par l'installation.

👉 【 Environnement d'installation et d'exploitation