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, wodurch die Entwicklungsschwierigkeiten erheblich verringert und Leistungsprobleme reduziert werden, 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 begannen 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 der asynchronen Verarbeitung nutzen zu können. Große Bequemlichkeit.

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 der Einfachheit nachgehen, 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, wird 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 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.7.192 sind die Ergebnisse dieses Codes wie folgt:

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

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 dieser starke Leistungsabfall ist völlig inakzeptabel.

Da fibjs Glasfaser verwendet, kann es die Eigenschaften der JavaScript-Sprache selbst voll ausnutzen und die überlegene Leistung von Version 8 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 Daten mithilfe der Synchronisierung direkt lesen und speichern und auf dieser Grundlage ein vollständiges Geschäft aufbauen. 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 Synchronisierungs- als auch Asynchronisierungsschnittstellen bereitstellen, um das Gleichgewicht zwischen Asynchronität und Leistung auszugleichen. Gewöhnlichere Entwickler werden sich dafür entscheiden, nur eine asynchrone Schnittstelle bereitzustellen. 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 Module verschiedener Programmierparadigmen leicht integrieren und mit minimalen Entwicklungskosten in Synchronisationsparadigmen umwandeln, um die durch Paradigmenansteckung verursachten Katastrophen effektiv zu vermeiden.

Erfahrung starten

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

👉 [ Installations- und Betriebsumgebung ]