Guida Guida allo sviluppo

Che cos'è fibjs?

Fibjs è un framework di sviluppo di application server progettato principalmente per lo sviluppo di backend Web. Si basa sul motore JavaScript di Google v8 e sceglie una soluzione di concorrenza diversa rispetto al callback tradizionale. Fibjs utilizza la fibra per isolare la complessità aziendale derivante dalle chiamate asincrone nel livello del framework, il che riduce notevolmente la difficoltà di sviluppo e riduce i problemi di prestazioni causati dalla frequente elaborazione asincrona dello spazio utente.

Per motivi storici, JavaScript viene utilizzato principalmente per l'elaborazione dell'interfaccia utente del browser, mentre lo sviluppo dell'interfaccia utente è una tipica modalità basata su eventi a thread singolo, pertanto JavaScript forma anche la programmazione asincrona come paradigma di programmazione principale.

Con il successo di JavaScript, sempre più persone stanno iniziando ad applicare JavaScript ad altri scenari. Allo stesso tempo, le persone stanno scoprendo sempre più che l'elaborazione asincrona non è la scelta più appropriata in molti scenari.

Ritorna allo sviluppo originale e agile

Fibjs utilizza la fibra a livello di framework per isolare la complessità aziendale derivante dalle chiamate asincrone e incapsula l'elaborazione asincrona di io in chiamate sincrone più intuitive Gli ingegneri devono solo scrivere codice secondo la consueta logica aziendale sincrona, che può essere apprezzata dall'elaborazione asincrona. Grande comodità.

Il seguente codice è tratto dalla documentazione per il modulo mysql:

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, fai la stessa cosa, il codice è il seguente:

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

Se stai perseguendo la semplicità, puoi persino scrivere il codice in questo modo:

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

Possiamo confrontare chiaramente le differenze tra i due diversi stili di programmazione. Un numero minore di codice porta a un minor numero di errori e, poiché il codice viene ridotto, la logica del codice è più chiara e ne trarranno vantaggio sia lo sviluppo che la manutenzione.

Abbraccia l'alta energia

Sebbene sia possibile aumentare facilmente la velocità di risposta espandendo il server, le prestazioni dovrebbero comunque costituire una base importante per la scelta di un framework di sviluppo. Con l'introduzione di ES7, async è stato introdotto come nuovo modello di sviluppo asincrono. Tuttavia, quando ci piace lo stile di sincronizzazione portato da asincrono, dobbiamo affrontare il suo impatto sulle prestazioni.

Possiamo usare un pezzo di codice di prova per confrontare le differenze di prestazioni tra diversi stili di programmazione:

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

Nell'ultima versione v8 v6.7.192, il risultato di questo codice è il seguente:

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

Dai risultati del test possiamo vedere chiaramente che quando l'asincrono è ampiamente utilizzato in un progetto, il server impiegherà molto tempo a elaborare la chiamata e restituire la funzione asincrona. Abbiamo anche trovato questo nel test effettivo di alcune applicazioni server. E questo forte calo delle prestazioni è totalmente inaccettabile.

Fibjs utilizza la fibra per sfruttare appieno le funzionalità del linguaggio JavaScript e massimizzare le prestazioni della v8. Gli ingegneri possono facilmente massimizzare le prestazioni dei loro server.

Scelta flessibile del paradigma senza essere rapito

Scegliere di usare fibjs non significa che devi usare uno stile di sviluppo sincrono, infatti fibjs supporta qualsiasi paradigma di programmazione asincrona che tu abbia mai visto e ha la flessibilità di passare da uno stile sincrono a uno asincrono.

Che si tratti di callback o asincrono, c'è un difetto fatale, che è contagioso. Finché una funzione è callback o asincrona, tutte le altre funzioni che dipendono da essa devono essere callback o asincrone. Ciò comporterà enormi costi di sviluppo nello sviluppo di software su larga scala.

Prendi un semplice scenario di sviluppo del server come esempio. All'inizio del progetto, abbiamo scelto la memoria come archivio di dati di sessione, a questo punto possiamo utilizzare il metodo di sincronizzazione per leggere e archiviare direttamente i dati e, in base a ciò, sviluppare un business completo. Con l'aumentare della scala aziendale, è necessario archiviare i dati della sessione in redis o mongodb. A questo punto, è necessario modificare le operazioni relative alla sessione in modalità asincrona.

In teoria, possiamo modificare ciascuna funzione a turno per soddisfare i requisiti della funzione da cui dipende, ma ciò richiede che comprendiamo appieno tutti i moduli e che siano in grado di modificarli. Questo è assolutamente impossibile da fare quando si sviluppa lo sviluppo collaborativo di più persone o si utilizzano moduli di terze parti.

Pertanto, tutti i moduli comuni devono fornire interfacce sia sincrone che asincrone per bilanciare l'equilibrio tra asincrono e prestazioni. Gli sviluppatori più normali sceglieranno di fornire solo l'interfaccia asincrona. Ciò provoca un disastro delle prestazioni.

In fibjs, puoi facilmente risolvere problemi simili ed evitare l'infezione esplicita asincrona non controllata:

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 può utilizzare util.sync per trasformare una funzione di richiamata o asincrona in una funzione di sincronizzazione e chiamarla direttamente. In questo modo, possiamo facilmente integrare moduli di diversi paradigmi di programmazione e trasformarli in paradigmi di sincronizzazione con costi di sviluppo minimi, evitando efficacemente il disastro causato dall'infezione di paradigma.

Inizia l'esperienza

Pronto per iniziare una piacevole esperienza di sviluppo? Quindi, iniziamo con l'installazione.

👉 [Ambiente di installazione e operativo ]