Leitfaden Entwicklungshandbuch

Was ist Fibjs?

fibjs ist ein Anwendungsserver-Entwicklungsframework, das hauptsächlich für die Web-Back-End-Entwicklung entwickelt wurde. Es basiert auf der Google v8-JavaScript-Engine und wählt eine gleichzeitige Lösung, die sich vom herkömmlichen Rückruf unterscheidet. fibjs verwendet Glasfaser, um die durch asynchrone Aufrufe auf der Framework-Ebene verursachte Geschäftskomplexität zu isolieren. Dies verringert die Entwicklungsschwierigkeiten erheblich und verringert die Leistungsprobleme, die durch häufige asynchrone Verarbeitung im Benutzerbereich verursacht werden.

Aus historischen Gründen wird JavaScript hauptsächlich für die Verarbeitung der Browser-Benutzeroberfläche verwendet. Die Entwicklung der Benutzeroberfläche ist ein typisches ereignisgesteuertes Single-Thread-Modell. Daher hat JavaScript auch ein Programmierparadigma mit asynchroner Verarbeitung als Hauptprogrammierparadigma gebildet.

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 zu den Grundlagen, agile Entwicklung

fibjs verwendet Glasfaser in der Framework-Schicht, um die durch asynchrone Aufrufe verursachte Geschäftskomplexität zu isolieren, und kapselt die asynchrone Verarbeitung von io in einen intuitiveren synchronen Anruf. Ingenieure müssen nur Code gemäß der üblichen synchronen Geschäftslogik schreiben, um die Vorteile von nutzen zu können asynchrone Verarbeitung. Sehr bequem.

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 lautet der Code wie folgt, um dieselbe Arbeit abzuschließen:

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 Kürze suchen, können Sie den Code sogar folgendermaßen 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, die durch zwei verschiedene Programmierstile hervorgerufen werden, klar vergleichen. Weniger Code bringt weniger Fehler mit sich. Wenn der Code abnimmt, ist die Logik des Codes klarer. Sowohl die Entwicklung als auch die Wartung werden davon profitieren.

Umfassen Sie hohe Energie

Obwohl wir die Antwortgeschwindigkeit durch Erweiterung des Servers leicht erhöhen können, sollte die Leistung dennoch eine der wichtigsten Grundlagen 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 durch Async eingebrachten Synchronisationsstil 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 lauten die Ergebnisse dieses Codes wie folgt:

1 2 3
async: 3.75ms callback: 0.161ms sync: 0.035ms

Aus den Testergebnissen können wir klar erkennen, dass der Server viel Zeit für die Verarbeitung von asynchronen Funktionsaufrufen und -rückgaben benötigt, wenn Async im Projekt weit verbreitet ist. Wir haben diesen Punkt auch beim tatsächlichen Testen einiger serverseitiger Anwendungen gefunden. Und diese Art von starkem Leistungsabfall ist völlig inakzeptabel.

Da fibjs fibre verwendet, kann es die Eigenschaften der JavaScript-Sprache selbst voll ausnutzen und die überlegene Leistung von v8 maximieren. Ingenieure können die Leistung des Servers problemlos maximieren.

Flexible Paradigmenwahl ohne Entführung

Die Wahl von fibjs bedeutet nicht, dass Sie einen synchronen Entwicklungsstil verwenden müssen. Tatsächlich unterstützt fibjs jedes asynchrone Programmierparadigma, das Sie gesehen haben, und kann flexibel zwischen synchronen und asynchronen Stilen wechseln.

Sowohl Rückruf als auch Asynchronität haben einen schwerwiegenden Fehler, das heißt Ansteckung. Solange eine Funktion Callback oder Async ist, müssen alle anderen Funktionen, die davon abhängen, Callback oder Async sein. Dies wird enorme Entwicklungskosten bei der groß angelegten 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 die Daten direkt zu lesen und zu speichern und auf dieser Grundlage ein vollständiges Geschäft aufzubauen. Mit der Entwicklung der Geschäftsskala müssen wir Sitzungsdaten in Redis oder Mongodb speichern. Zu diesem Zeitpunkt müssen wir sitzungsbezogene Vorgänge in den asynchronen Modus ändern.

Theoretisch können wir jede Funktion nacheinander modifizieren, damit sie den Anforderungen der Funktionen entspricht, von denen sie abhängen. Dies erfordert jedoch, dass wir alle Module vollständig verstehen und in der Lage sind, sie zu modifizieren. Dies ist bei der kollaborativen Entwicklung für mehrere Personen oder bei der Verwendung von Modulen von Drittanbietern völlig unmöglich.

Daher müssen alle gängigen Module sowohl synchrone als auch asynchrone Schnittstellen bereitstellen, um das Gleichgewicht zwischen Asynchronität und Leistung auszugleichen. Gewöhnlichere Entwickler werden nur die asynchrone Schnittstelle bereitstellen. Dies führt zu einer Leistungskatastrophe.

In Fibjs können Sie ähnliche Probleme leicht lösen und explizite asynchrone und unkontrollierte Infektionen 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 Rückruf- oder asynchrone Funktionen in Synchronisierungsfunktionen umzuwandeln und direkt aufzurufen. Auf diese Weise können wir problemlos Module verschiedener Programmierparadigmen integrieren und sie mit minimalen Entwicklungskosten in Synchronisationsparadigmen umwandeln, um die durch Paradigmenansteckung verursachten Katastrophen effektiv zu vermeiden.

Fangen Sie an zu erleben

Sind Sie bereit, eine angenehme Entwicklungserfahrung zu beginnen? Beginnen wir also mit der Installation.

👉 [ Installations- und Betriebsumgebung ]