Leitfaden-Entwicklungsleitfaden

Was ist fibjs?

fibjs ist ein Framework zur Entwicklung von Anwendungsservern, das hauptsächlich für die Entwicklung von Web-Back-Ends entwickelt wurde, auf der JavaScript-Engine Google v8 basiert und eine vom herkömmlichen Callback abweichende gleichzeitige Lösung wählt. fibjs verwendet Glasfaser, um die durch asynchrone Aufrufe auf der Framework-Ebene verursachte Geschäftskomplexität zu isolieren, was die Schwierigkeit der Entwicklung erheblich reduziert und die Leistungsprobleme verringert, die durch häufige asynchrone Verarbeitung im Benutzerbereich verursacht werden.

Aus historischen Gründen wird JavaScript hauptsächlich für die Browser-UI-Verarbeitung verwendet.Die UI-Entwicklung ist ein typisches ereignisgesteuertes Singlethread-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 Leute 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 Aufruf. Ingenieure müssen nur Code gemäß der üblichen synchronen Geschäftslogik schreiben, um die Vorteile von . zu genießen asynchrone Verarbeitung Großer Komfort.

Der folgende Code ist der Dokumentation des mysql-Moduls entnommen:

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, um dieselbe Arbeit abzuschließen, 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 Kürze suchen, können Sie den Code sogar 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, die durch zwei verschiedene Programmierstile entstehen, deutlich vergleichen. Weniger Code führt zu weniger Fehlern Wenn der Code kleiner wird, wird die Logik des Codes klarer. Sowohl die Entwicklung als auch die Wartung werden davon profitieren.

Umarme hohe Energie

Obwohl wir die Reaktionsgeschwindigkeit durch die Erweiterung des Servers leicht erhöhen können, sollte die Performance dennoch eine der wichtigen Grundlagen für die Wahl eines Entwicklungsframeworks sein. Mit der Einführung von ES7 wurde Async als neues asynchrones Entwicklungsmodell in JavaScript eingeführt. Wenn wir jedoch den Synchronisierungsstil von Async genießen, müssen wir uns auch dessen Auswirkungen auf die Leistung stellen.

Wir können ein Stück 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 v8 sind die Ergebnisse dieses Codes wie folgt:

1 2 3
async: 0.539ms callback: 0.221ms sync: 0.061ms

Aus den Testergebnissen können wir eindeutig erkennen, dass der Server viel Zeit damit verbringen wird, asynchrone Funktionsaufrufe und -rückgaben zu verarbeiten, wenn Async im Projekt weit verbreitet ist. Diesen Punkt haben wir auch beim tatsächlichen Testen einiger serverseitiger Anwendungen festgestellt. Und solch ein starker Leistungsabfall ist völlig inakzeptabel.

Da fibjs Glasfaser 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 leicht maximieren.

Flexible Paradigmenwahl, ohne entführt zu werden

Die Entscheidung für die Verwendung von fibjs bedeutet nicht, dass Sie einen synchronen Entwicklungsstil verwenden müssen, tatsächlich unterstützt fibjs jedes asynchrone Programmierparadigma, das Sie kennen, und kann flexibel zwischen synchronen und asynchronen Stilen wechseln.

Sowohl Callback als auch Async haben einen fatalen Fehler, nämlich 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 in der groß angelegten Softwareentwicklung mit sich bringen.

Nehmen Sie als Beispiel ein einfaches Serverentwicklungsszenario. Zu Beginn des Projekts haben wir uns als Speicher für die Sitzungsdaten entschieden, jetzt können wir die Daten direkt mit der Sync-Methode auslesen und speichern und darauf aufbauend ein komplettes Geschäft entwickeln. 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 der Reihe nach ändern, damit sie die Anforderungen der Funktionen erfüllen, von denen sie abhängen, aber dazu müssen wir alle Module vollständig verstehen und in der Lage sein, sie zu ändern. Dies ist bei der kollaborativen Entwicklung mit mehreren Personen oder bei der Verwendung von Modulen von Drittanbietern völlig unmöglich.

Daher müssen alle gängigen Module sowohl Sync- als auch Async-Schnittstellen bereitstellen, um das Gleichgewicht zwischen Asynchronität und Leistung auszugleichen. Normalere Entwickler werden sich dafür entscheiden, nur die asynchrone Schnittstelle bereitzustellen. Dies führt zu einer Leistungskatastrophe.

In fibjs können Sie ähnliche Probleme leicht lösen und eine explizite asynchrone und 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 kann util.sync verwenden, um Callback- oder Async-Funktionen in Sync-Funktionen umzuwandeln und diese direkt aufzurufen. Auf diese Weise können wir Module verschiedener Programmierparadigmen einfach integrieren und mit minimalen Entwicklungskosten in Sync-Paradigmen umwandeln, wodurch die durch Paradigmenansteckung verursachten Katastrophen effektiv vermieden werden.

Fang an zu erleben

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

👉 [ Installations- und Betriebsumgebung ]