Guide de développement du guide

Qu'est-ce que fibjs ?

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

Pour des raisons historiques, JavaScript est principalement utilisé pour le traitement de l'interface utilisateur du navigateur. Le développement de l'interface utilisateur est un modèle typique basé sur des événements à thread unique. Par conséquent, JavaScript a également formé un paradigme de programmation avec le traitement asynchrone comme paradigme de programmation principal.

Avec le succès de JavaScript, de plus en plus de personnes commencent à appliquer JavaScript à d'autres scénarios. Dans le même temps, les gens constatent de plus en plus que le traitement asynchrone n'est pas le choix le plus approprié dans de nombreux scénarios.

Retour aux sources, développement agile

fibjs utilise la fibre dans la couche framework pour isoler la complexité métier causée par les appels asynchrones, et encapsule le traitement asynchrone d'io dans un appel synchrone plus intuitif. Les ingénieurs n'ont qu'à écrire du code conformément à la logique métier synchrone habituelle pour profiter des avantages de traitement asynchrone Grande commodité.

Le code suivant est tiré 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 effectuer 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 brièveté, vous pouvez même écrire le 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 provoquées par deux styles de programmation différents. Moins de code apportera moins d'erreurs. Au fur et à mesure que le code diminue, la logique du code est plus claire. Le développement et la maintenance en bénéficieront.

Adoptez la haute énergie

Bien que nous puissions facilement augmenter la vitesse de réponse en étendant le serveur, les performances doivent toujours être l'une des bases importantes pour le choix d'un framework 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 provoqué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, les résultats de ce code sont les suivants :

1 2 3
async: 0.539ms callback: 0.221ms sync: 0.061ms

Nous pouvons clairement savoir d'après les résultats des tests que lorsque l'async est largement utilisé dans le projet, le serveur passera beaucoup de temps à traiter les appels et les retours de fonction async. Nous avons également trouvé ce point dans les tests réels de certaines applications côté serveur. Et ce genre de baisse brutale 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 du 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 tous les paradigmes de programmation asynchrone que vous avez vus et peut basculer de manière flexible entre les styles synchrone et asynchrone.

Le rappel et l'async ont tous deux un défaut fatal, c'est la contagion. 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 des coûts de développement énormes dans le développement de logiciels à grande échelle.

Prenons l'exemple d'un scénario de développement de serveur simple. Au début du projet, nous avons choisi la mémoire comme stockage des données de session.À ce stade, nous pouvons utiliser la méthode de synchronisation pour lire et stocker directement les données, et développer une entreprise complète basée sur cela. Avec le développement de l'échelle commerciale, 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 chaque fonction à tour de rôle pour qu'elles répondent aux exigences des fonctions dont elles dépendent, mais cela nous oblige à bien comprendre tous les modules et à avoir la capacité de les modifier. Ceci est totalement impossible à accomplir lors d'un développement collaboratif multi-personnes ou lors de l'utilisation de modules tiers.

Par conséquent, tous les modules courants doivent fournir à la fois des interfaces synchrones et asynchrones pour équilibrer l'équilibre entre asynchrone et performances. Les développeurs plus ordinaires choisiront de fournir uniquement l'interface asynchrone. Cela conduit à un désastre de performance.

Dans fibjs, vous pouvez facilement résoudre des problèmes similaires et éviter une infection explicite asynchrone et incontrôlée :

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 convertir des 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 convertir en paradigmes de synchronisation avec des coûts de développement minimes, évitant efficacement les catastrophes causées par la contagion des paradigmes.

Commencer à expérimenter

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

👉 [ Environnement d' installation et d'exploitation ]