Guide Entwicklungshandbuch

Was ist Fibjs?

Fibjs ist ein Anwendungsserver-Entwicklungsframework, das hauptsächlich für die Web-Backend-Entwicklung entwickelt wurde. Es baut auf der JavaScript-Engine von Google 8 auf und wählt eine andere Lösung für den gemeinsamen Zugriff als herkömmlicher Rückruf. Fibjs verwendet Glasfaser, um die geschäftliche Komplexität zu isolieren, die durch asynchrone Aufrufe in der Framework-Schicht verursacht wird. Dies verringert die Entwicklungsschwierigkeiten erheblich und die Leistungsprobleme, die durch häufige asynchrone Verarbeitung des Benutzerraums verursacht werden.

Aus historischen Gründen wird JavaScript hauptsächlich für die Browser-UI-Verarbeitung verwendet.Die UI-Entwicklung ist ein typischer ereignisgesteuerter Single-Thread-Modus, sodass JavaScript auch die asynchrone Programmierung als Hauptprogrammierparadigma darstellt.

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.

Kehren Sie zur ursprünglichen, agilen Entwicklung zurück

Fibjs verwendet Glasfaser in der Framework-Schicht, um die durch asynchrone Aufrufe verursachte geschäftliche Komplexität zu isolieren, und kapselt die asynchrone Verarbeitung von io in intuitivere synchrone Aufrufe. 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 ist der Code 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 streben, 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 den beiden verschiedenen Programmierstilen klar vergleichen. Weniger Code führt zu weniger Fehlern, und wenn der Code reduziert wird, ist die Logik des Codes klarer, und sowohl die Entwicklung als auch die Wartung profitieren davon.

Umfassen Sie hohe Energie

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

Wir können einen Testcode verwenden, um Leistungsunterschiede zwischen verschiedenen Programmierstilen zu vergleichen:

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 lautet das Ergebnis dieses Codes wie folgt:

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

Die Testergebnisse zeigen deutlich, dass der Server viel Zeit für die Verarbeitung des Aufrufs und die Rückkehr der Async-Funktion benötigt, wenn Async in einem Projekt häufig verwendet wird. Dies haben wir auch beim Testen einiger Serveranwendungen festgestellt. Und dieser starke Leistungsabfall ist völlig inakzeptabel.

Fibjs nutzt Glasfaser, um die Funktionen der JavaScript-Sprache voll auszunutzen und die Leistung von v8 zu maximieren. Ingenieure können die Leistung ihrer Server problemlos maximieren.

Flexible Wahl des Paradigmas, ohne entführt zu werden

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

Ob Rückruf oder asynchron, es liegt ein schwerwiegender Fehler vor, der ansteckend ist. 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 haben wir Speicher als Sitzungsdatenspeicher ausgewählt. Zu diesem Zeitpunkt können wir die Synchronisierungsmethode verwenden, um Daten direkt zu lesen und zu speichern und auf dieser Grundlage ein vollständiges Unternehmen aufzubauen. Mit zunehmender Geschäftsskala müssen die Sitzungsdaten in Redis oder Mongodb gespeichert werden. Zu diesem Zeitpunkt müssen die sitzungsbezogenen Vorgänge in den asynchronen Modus geändert werden.

Theoretisch können wir jede Funktion der Reihe nach an die Anforderungen der Funktion anpassen, von der sie abhängt. Dies setzt jedoch voraus, dass wir alle Module vollständig verstehen und in der Lage sind, sie zu ändern. Dies ist völlig unmöglich, wenn mehrere Personen zusammenarbeiten oder wenn Module von Drittanbietern verwendet werden.

Daher müssen alle gängigen Module sowohl Synchronisations- als auch Asynchronisationsschnittstellen bereitstellen, um das Gleichgewicht zwischen Asynchronität und Leistung auszugleichen. Normalere Entwickler stellen nur die asynchrone Schnittstelle zur Verfügung. Dies führt zu einer Leistungsstörung.

In Fibjs können Sie ähnliche Probleme leicht lösen und eine explizite asynchrone unkontrollierte Infektion 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 eine Callback- oder Async-Funktion in eine Sync-Funktion umzuwandeln und direkt aufzurufen. Auf diese Weise können wir auf einfache Weise Module mit unterschiedlichen Programmierparadigmen integrieren und mit minimalem Entwicklungsaufwand in Synchronisationsparadigmen umwandeln, um die durch Paradigmeninfektion verursachte Katastrophe wirksam zu vermeiden.

Beginnen Sie die Erfahrung

Bereit für ein angenehmes Entwicklungserlebnis? Beginnen wir also mit der Installation.

👉 [ Installations- und Betriebsumgebung ]