Guide Entwicklungshandbuch

Was ist Fibjs?

fibjs ist ein Anwendungsserver-Entwicklungsframework, das hauptsächlich für die Entwicklung von Web-Backends entwickelt wurde. Es basiert auf der JavaScript-Engine von Google v8 und wählt eine andere parallele Lösung als das herkömmliche Callback. Fibjs verwendet Glasfaser, um die geschäftliche Komplexität zu isolieren, die durch asynchrone Aufrufe auf der Framework-Ebene verursacht wird. Dies verringert die Entwicklungsschwierigkeiten und die Leistungsprobleme, die durch häufige asynchrone Verarbeitung im Benutzerbereich verursacht werden.

Aus historischen Gründen wird JavaScript hauptsächlich für die Benutzeroberflächenverarbeitung in Browsern verwendet. Die Benutzeroberflächenentwicklung ist ein typisches ereignisgesteuertes Single-Thread-Modell, sodass JavaScript auch die asynchrone Programmierung als Hauptprogrammierparadigma definiert hat.

Mit dem Erfolg von JavaScript beginnen immer mehr Menschen, JavaScript auf andere Szenarien anzuwenden. Gleichzeitig stellen die Menschen zunehmend fest, dass die asynchrone Verarbeitung in vielen Szenarien nicht die am besten geeignete Wahl ist.

Zurück zur wahren, agilen Entwicklung

Fibjs verwendet Glasfaser auf der Framework-Ebene, um die durch asynchrone Aufrufe verursachte geschäftliche Komplexität zu isolieren, und kapselt die asynchrone Verarbeitung von io in intuitivere synchrone Aufrufe. Ingenieure müssen nur Code gemäß der üblichen synchronen Geschäftslogik schreiben, um die Vorteile der asynchronen Verarbeitung zu nutzen. Großer Komfort.

Der folgende Code stammt aus der Dokumentation des mysql-Moduls:

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!'); }); }); }); });

In Fibjs wird die gleiche Arbeit geleistet, der Code lautet wie folgt:

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!');

Wenn Sie nach Einfachheit suchen, können Sie den Code auch so schreiben:

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!');

Wir können die Unterschiede zwischen zwei verschiedenen Programmierstilen klar vergleichen. Weniger Code führt zu weniger Fehlern, und wenn der Code abnimmt, wird die Logik des Codes klarer, und sowohl die Entwicklung als auch die Wartung sind von Vorteil.

Umfassen Sie hohe Energie

Durch die Erweiterung des Servers kann die Antwortgeschwindigkeit zwar problemlos erhöht werden, die Leistung sollte jedoch einer der wichtigsten Gründe für die Auswahl eines Entwicklungsframeworks sein. Mit der Einführung von ES7 wurde Async als neues asynchrones Entwicklungsmodell in JavaScript eingeführt. Wenn wir jedoch den Synchronisationsstil von Async genießen, müssen wir uns auch dessen Auswirkungen auf die Leistung stellen.

Wir können einen Testcode verwenden, um die Leistungsunterschiede zu vergleichen, die durch verschiedene Programmierstile verursacht werden:

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();

Unter der neuesten Version 8, Version 6.7.192, wird dieser Code wie folgt ausgeführt:

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

Aus den Testergebnissen können wir eindeutig erkennen, dass der Server viel Zeit für die Verarbeitung des Aufrufs und die Rückkehr der Async-Funktion benötigt, wenn Async im Projekt weit verbreitet ist. Wir haben dies auch beim Testen einiger serverseitiger Anwendungen festgestellt. Und der starke Leistungsabfall ist völlig inakzeptabel.

Da fibjs fiber verwendet, können die Funktionen der JavaScript-Sprache selbst voll genutzt und die überlegene Leistung von v8 maximiert werden. Ingenieure können die Serverleistung problemlos maximieren.

Flexible Wahl des Paradigmas, ohne entführt zu werden

Wenn Sie sich für die Verwendung von Fibjs entscheiden, müssen Sie keinen synchronen Entwicklungsstil verwenden. Fibjs unterstützt in der Tat jedes bekannte asynchrone Programmierparadigma und bietet die Flexibilität, zwischen synchronen und asynchronen Stilen zu wechseln.

Egal, ob es sich um einen Rückruf oder einen asynchronen Vorgang handelt, es liegt ein schwerwiegender Fehler vor, der eine Ansteckung darstellt. Solange eine Funktion Callback oder Async ist, müssen alle anderen davon abhängigen Funktionen Callback oder Async sein. Dies wird enorme Entwicklungskosten in der umfangreichen Softwareentwicklung mit sich bringen.

Nehmen Sie als Beispiel ein einfaches Serverentwicklungsszenario. Zu Beginn des Projekts wählten wir Speicher als Sitzungsdatenspeicher, um Daten mit der Synchronisationsmethode direkt zu lesen und zu speichern und auf dieser Basis ein vollständiges Geschäft aufzubauen. Mit der Entwicklung der Business-Skalierung müssen Sitzungsdaten in Redis oder Mongodb gespeichert werden. Zu diesem Zeitpunkt müssen sitzungsbezogene Vorgänge in den asynchronen Modus geändert werden.

Theoretisch können wir jede Funktion der Reihe nach ändern, um sie an die Anforderungen der abhängigen Funktion anzupassen. Dies setzt jedoch voraus, dass wir alle Module vollständig verstehen und in der Lage sind, sie zu ändern. Dies ist bei der Entwicklung in Zusammenarbeit mit mehreren Personen oder bei der Verwendung von Modulen von Drittanbietern völlig unmöglich.

Daher müssen alle gängigen Module sowohl Synchronisations- als auch Asynchronisationsschnittstellen bereitstellen, um das Gleichgewicht zwischen Asynchronität und Leistung auszugleichen. Normalere Entwickler werden sich dafür entscheiden, nur eine asynchrone Schnittstelle bereitzustellen. Dies kann zu Leistungsstörungen führen.

In Fibjs können Sie ähnliche Probleme leicht lösen und eine explizite asynchrone und unkontrollierte Übertragung vermeiden:

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 können util.sync verwenden, um Callback- oder Async-Funktionen in Sync-Funktionen umzuwandeln und direkt aufzurufen. Auf diese Weise können wir auf einfache Weise Module mit unterschiedlichen Programmierparadigmen integrieren und mit minimalen Entwicklungskosten in Synchronisationsparadigmen umwandeln, um die durch Paradigmeninfektion verursachte Katastrophe wirksam zu vermeiden.

Erfahrung beginnen

Bist du bereit für eine unterhaltsame Entwicklungserfahrung? Beginnen wir also mit der Installation.

👉 [ Installations- und Betriebsumgebung ]