Gids Ontwikkelingsgids

Wat is fibjs?

fibjs is een framework voor de ontwikkeling van applicatieservers dat voornamelijk is ontworpen voor web-backend-ontwikkeling. Het is gebaseerd op de Google v8 JavaScript-engine en kiest een andere concurrency-oplossing dan de traditionele callback. fibjs gebruikt glasvezel om de zakelijke complexiteit te isoleren die wordt veroorzaakt door asynchrone oproepen op de framework-laag, waardoor de moeilijkheid van ontwikkeling aanzienlijk wordt verminderd en de prestatieproblemen worden verminderd die worden veroorzaakt door frequente asynchrone verwerking in de gebruikersruimte.

Vanwege historische redenen wordt JavaScript voornamelijk gebruikt voor UI-verwerking van browsers. UI-ontwikkeling is een typisch single-threaded event-driven model, dus JavaScript heeft ook asynchrone verwerking gevormd als het belangrijkste programmeerparadigma.

Met het succes van JavaScript begonnen steeds meer mensen JavaScript toe te passen op andere scenario's. Tegelijkertijd komen mensen er steeds meer achter dat asynchrone verwerking in veel scenario's niet de meest geschikte keuze is.

Terug naar de basis, agile ontwikkeling

fibjs gebruikt glasvezel in de framework-laag om de zakelijke complexiteit van asynchrone oproepen te isoleren en kapselt de asynchrone verwerking van io in meer intuïtieve synchrone oproepen in. Ingenieurs hoeven alleen maar code te schrijven volgens de gebruikelijke synchrone bedrijfslogica om te profiteren van de voordelen van asynchrone verwerking Groot gemak.

Het volgende codefragment is afkomstig uit de documentatie voor de mysql-module:

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, om hetzelfde werk te doen, is de code als volgt:

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!');

Als u op zoek bent naar beknoptheid, kunt u uw code zelfs als volgt schrijven:

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!');

We kunnen de verschillen die worden veroorzaakt door de twee verschillende programmeerstijlen duidelijk vergelijken. Minder code leidt tot minder fouten Met de reductie van code wordt de logica van de code duidelijker en profiteren zowel de ontwikkeling als het onderhoud ervan.

omarm hoge energie

Hoewel we de reactiesnelheid gemakkelijk kunnen verhogen door de server uit te breiden, moeten prestaties nog steeds een van de belangrijke uitgangspunten zijn bij het kiezen van een ontwikkelframework. Met de introductie van ES7 werd async in JavaScript geïntroduceerd als een nieuw asynchroon ontwikkelingspatroon. Als we echter genieten van de synchrone stijl die async met zich meebrengt, moeten we ook de impact ervan op de prestaties onder ogen zien.

We kunnen een stukje testcode gebruiken om de prestatieverschillen te vergelijken die worden veroorzaakt door verschillende programmeerstijlen:

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();

Onder de nieuwste v8 is het resultaat van deze code als volgt:

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

Uit de testresultaten kunnen we duidelijk opmaken dat wanneer async veel wordt gebruikt in het project, de server veel tijd zal besteden aan het verwerken van de aanroep en het retourneren van asynchrone functies. We hebben dit ook gevonden in enkele daadwerkelijke tests van server-side applicaties. En deze scherpe prestatiedaling is volkomen onaanvaardbaar.

Omdat fibjs glasvezel gebruikt, kan het volledig gebruik maken van de kenmerken van de JavaScript-taal zelf en de superieure prestaties van v8 maximaliseren. Ingenieurs kunnen eenvoudig de prestaties van de server maximaliseren.

Flexibele keuze van paradigma zonder ontvoerd te worden

Kiezen voor het gebruik van fibjs betekent niet dat je een synchrone ontwikkelingsstijl moet gebruiken, in feite ondersteunt fibjs elk asynchrone programmeerparadigma dat je hebt gezien, en je kunt flexibel schakelen tussen synchrone en asynchrone stijlen.

Of het nu callback of async is, er is een fatale fout, namelijk besmetting. Zolang een functie callback of asynchroon is, moeten alle andere functies die ervan afhankelijk zijn, callback of asynchroon zijn. Dit zal enorme ontwikkelingskosten met zich meebrengen bij grootschalige softwareontwikkeling.

Neem een ​​eenvoudig scenario voor serverontwikkeling als voorbeeld. Aan het begin van het project kozen we geheugen als opslag van sessiegegevens.Op dit moment kunnen we de synchronisatiemethode gebruiken om gegevens direct uit te lezen en op te slaan, en op basis hiervan een compleet bedrijf te ontwikkelen. Met de ontwikkeling van zakelijke schaal moeten we sessiegegevens opslaan in redis of mongodb. Op dit moment moeten we sessiegerelateerde bewerkingen wijzigen in asynchrone modus.

In theorie kunnen we elke functie op zijn beurt aanpassen om ze te laten voldoen aan de vereisten van de functies waarvan ze afhankelijk zijn, maar dit vereist dat we alle modules volledig begrijpen en de mogelijkheid hebben om ze aan te passen. Dit is volledig onmogelijk bij gezamenlijke ontwikkeling door meerdere personen of bij het gebruik van modules van derden.

Daarom moeten alle gemeenschappelijke modules zowel gesynchroniseerde als asynchrone interfaces bieden om de balans tussen asynchronie en prestaties in evenwicht te brengen. Meer gewone ontwikkelaars zullen ervoor kiezen om alleen asynchrone interfaces aan te bieden. Waardoor een prestatieramp wordt veroorzaakt.

In fibjs kun je soortgelijke problemen eenvoudig oplossen, waarbij je expliciete asynchrone ongecontroleerde besmetting vermijdt:

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 kan util.sync gebruiken om een ​​callback- of asynchrone functie om te zetten in een synchronisatiefunctie en deze direct aan te roepen. Op deze manier kunnen we eenvoudig modules van verschillende programmeerparadigma's integreren en ze transformeren in synchronisatieparadigma's met minimale ontwikkelingskosten, waardoor rampen als gevolg van paradigmabesmetting effectief worden vermeden.

beginnen te ervaren

Klaar om een ​​plezierige ontwikkelingservaring te beginnen? Dus laten we beginnen met de installatie.

👉 【Installatie- en bedieningsomgeving