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 andere Parallelitätslösung als herkömmliche Rückrufe aus. Fibjs verwendet Glasfaser, um die durch asynchrone Aufrufe auf der Framework-Ebene verursachte Geschäftskomplexität zu isolieren. Dies reduziert 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 UI-Verarbeitung in Browsern verwendet. Die UI-Entwicklung ist ein typisches ereignisgesteuertes Single-Thread-Modell, daher hat JavaScript auch die asynchrone 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 Option ist.

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

Fibjs verwendet Glasfaser auf der Framework-Ebene, um die durch asynchrone Aufrufe verursachte Geschäftskomplexität zu isolieren, und kapselt die asynchrone Verarbeitung von io in einen intuitiveren synchronen Aufruf. Ingenieure müssen nur Code gemäß der üblichen synchronen Geschäftslogik schreiben, um die asynchrone 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 nach Einfachheit streben, können Sie sogar Code wie folgt 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, unabhängig davon, ob es sich um Entwicklung oder Wartung handelt, er wird 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.7.192 von Version 8 lauten die Ergebnisse dieser Codeausführung 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 des Aufrufs und die Rückgabe der asynchronen Funktion benötigt, wenn Async im Projekt weit verbreitet ist. Wir haben dies auch beim eigentlichen Testen einiger Serveranwendungen festgestellt. 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 synchronem Stil und asynchronem Stil wechseln.

Ob Rückruf oder Asynchronität, es gibt einen schwerwiegenden Fehler, der ansteckend ist. Solange eine Funktion Callback oder Async ist, müssen alle anderen Funktionen, die davon abhängen, Callback oder Async sein. Dies wird enorme Entwicklungskosten in der groß angelegten Softwareentwicklung mit sich bringen.

Nehmen Sie als Beispiel ein einfaches Serverentwicklungsszenario. In der frühen Phase des Projekts haben wir Speicher als Sitzungsdatenspeicher ausgewählt. Derzeit können wir mithilfe der Synchronisierung Daten 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 die sitzungsbezogenen Vorgänge in den asynchronen Modus ändern.

Theoretisch können wir jede Funktion nacheinander modifizieren, um sie an die Anforderungen der Funktion anzupassen, von der sie abhängt. Dazu müssen wir jedoch alle Module vollständig verstehen und in der Lage sein, sie zu modifizieren. Dies ist bei Verwendung der kollaborativen Entwicklung für mehrere Personen oder bei 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 asynchroner und Leistung auszugleichen. Normalere 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 Async-Funktionen in Sync-Funktionen 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.

Fangen Sie an zu erleben

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

👉 【 Installations- und Betriebsumgebung