Qu'est-ce que fibjs?
fibjs est un framework de développement de serveur d'application principalement conçu pour le développement de backend web.Il est basé sur le moteur JavaScript v8 de Google et choisit une solution de concurrence différente du callback traditionnel. fibjs utilise la fibre pour isoler la complexité commerciale causée par les appels asynchrones au niveau de la couche cadre, réduisant considérablement la difficulté de développement et réduisant 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 des navigateurs. Le développement de l'interface utilisateur est un modèle typique piloté par les événements à un seul thread, de sorte que JavaScript a également formé le traitement asynchrone comme principal paradigme de programmation.
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 trouvent de plus en plus que le traitement asynchrone n'est pas le choix le plus approprié dans de nombreux scénarios.
Retour aux fondamentaux, développement agile
fibjs utilise la fibre dans la couche cadre pour isoler la complexité métier apportée par les appels asynchrones, et encapsule le traitement asynchrone d'io dans des appels synchrones plus intuitifs. Les ingénieurs n'ont qu'à écrire du code selon la logique métier synchrone habituelle pour profiter des avantages apportés par l'asynchrone. traitement Grande commodité.
L'extrait de 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
32conn.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 accomplir le même travail, le code est le suivant :
1
2
3
4
5
6conn.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 votre code comme ceci :
1
2
3
4conn.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 les deux styles de programmation différents. Moins de code apportera moins d'erreurs.Avec la réduction de code, la logique du code sera plus claire, et le développement et la maintenance en bénéficieront.
embrasser la haute énergie
Bien que nous puissions facilement augmenter la vitesse de réponse en élargissant le serveur, les performances doivent toujours être l'une des bases importantes pour choisir 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 synchrone 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
39var 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, le résultat de ce code est le suivant :
1
2
3async: 0.539ms
callback: 0.221ms
sync: 0.061ms
Nous pouvons clairement savoir d'après les résultats des tests que lorsque l'asynchrone est largement utilisé dans le projet, le serveur passera beaucoup de temps à traiter l'appel et le retour des fonctions asynchrones. Nous avons également constaté cela dans certains tests réels d'applications côté 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 optimiser les performances du serveur.
Choix flexible du paradigme sans se faire kidnapper
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 vous pouvez basculer de manière flexible entre les styles synchrone et asynchrone.
Qu'il s'agisse de rappel ou d'asynchronisme, il y a une faille fatale, 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 asynchrones. Cela entraînera des coûts de développement énormes 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 de 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 activité complète basée sur celle-ci. Avec le développement de l'échelle commerciale, nous devons stocker les données de session dans redis ou mongodb. À l'heure actuelle, nous devons modifier les opérations liées à la session en mode asynchrone.
En théorie, on peut modifier tour à tour chaque fonction pour qu'elles répondent aux exigences des fonctions dont elles dépendent, mais cela nécessite de bien comprendre tous les modules et d'avoir la capacité de les modifier. Ceci est totalement impossible 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 de synchronisation et asynchrones pour équilibrer l'équilibre entre l'asynchronisme et les performances. Les développeurs plus ordinaires choisiront de ne fournir que des interfaces asynchrones. Provoquant ainsi un désastre de performance.
Dans fibjs, vous pouvez facilement résoudre des problèmes similaires, en évitant une contagion explicite asynchrone incontrôlée :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17var 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 une fonction de rappel ou asynchrone en une fonction de synchronisation et l'appeler directement. De cette manière, nous pouvons facilement intégrer des modules de différents paradigmes de programmation et les transformer en paradigmes de synchronisation avec des coûts de développement minimes, évitant ainsi efficacement les catastrophes causées par la contagion des paradigmes.
commencer à expérimenter
Prêt à commencer une expérience de développement agréable ? Alors, commençons par l'installation.