Guia Guia de desenvolupament

Què és fibjs?

fibjs és un marc de desenvolupament de servidor d'aplicacions dissenyat principalment per al desenvolupament de back-end web. Es basa en el motor JavaScript de Google v8 i tria una solució simultània diferent de la tradicional devolució de trucada. fibjs utilitza fibra per aïllar la complexitat empresarial causada per trucades asíncrones a la capa de marc, cosa que redueix en gran mesura la dificultat de desenvolupament i redueix els problemes de rendiment causats pel processament asíncron freqüent a l'espai de l'usuari.

Per motius històrics, JavaScript s'utilitza principalment per al processament de la interfície d'usuari del navegador. El desenvolupament de la interfície d'usuari és un model típic basat en esdeveniments d'un sol fil. Per tant, JavaScript també ha format un paradigma de programació amb processament asíncron com a paradigma de programació principal.

Amb l’èxit de JavaScript, cada vegada hi ha més gent que comença a aplicar JavaScript a altres escenaris. Al mateix temps, la gent troba cada vegada més que el processament asíncron no és l'elecció més adequada en molts escenaris.

Tornar als conceptes bàsics, desenvolupament àgil

fibjs utilitza fibra a la capa de marc per aïllar la complexitat empresarial causada per trucades asíncrones i encapsula el processament asíncron d’iO en una trucada síncrona més intuïtiva. Els enginyers només necessiten escriure codi d’acord amb la lògica de negoci síncrona habitual per gaudir dels avantatges de processament asíncron. Gran comoditat.

El següent codi està extret de la documentació del mòdul 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!'); }); }); }); });

A fibjs, per completar el mateix treball, el codi és el següent:

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

Si busqueu brevetat, fins i tot podeu escriure el codi així:

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

Podem comparar clarament les diferències provocades per dos estils de programació diferents. Menys codi comportarà menys errors. A mesura que el codi disminueix, la lògica del codi és més clara. El desenvolupament i el manteniment se’n beneficiaran.

Abraça alta energia

Tot i que podem augmentar fàcilment la velocitat de resposta ampliant el servidor, el rendiment hauria de ser una de les bases importants per triar un marc de desenvolupament. Amb la introducció d’ES7, async es va introduir a JavaScript com a nou model de desenvolupament asíncron. Tot i això, quan gaudim de l’estil de sincronització que proporciona async, també hem d’afrontar el seu impacte en el rendiment.

Podem utilitzar un codi de prova per comparar les diferències de rendiment provocades per diferents estils de programació:

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

Segons l'últim v8, els resultats d'aquest codi són els següents:

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

Podem saber clarament pels resultats de la prova que quan l’asincronització s’utilitza àmpliament en el projecte, el servidor passarà molt de temps processant trucades i devolucions de funcions d’asincronització. També hem trobat aquest punt en la prova real d'algunes aplicacions del servidor. I aquest tipus de forta caiguda del rendiment és totalment inacceptable.

Com que fibjs utilitza fibra, pot fer ple ús de les característiques del llenguatge JavaScript mateix i maximitzar el rendiment superior de v8. Els enginyers poden maximitzar fàcilment el rendiment del servidor.

Elecció flexible del paradigma sense ser segrestat

L'elecció d'utilitzar fibjs no vol dir que hàgiu d'utilitzar un estil de desenvolupament síncron. De fet, fibjs admet qualsevol paradigma de programació asíncrona que hàgiu vist i pot canviar de manera flexible entre estils síncrons i asíncrons.

Tant la devolució de trucada com l'asincronització tenen un defecte fatal, és a dir, el contagi. Mentre una funció sigui de devolució de trucada o asíncron, totes les altres funcions que en depenguin han de ser de devolució de trucada o asíncron. Això comportarà enormes costos de desenvolupament en el desenvolupament de programari a gran escala.

Agafeu com a exemple un escenari senzill de desenvolupament del servidor. Al començament del projecte, vam escollir la memòria com a emmagatzematge de dades de sessió. En aquest moment, podem llegir i emmagatzemar directament les dades mitjançant el mètode de sincronització i desenvolupar un negoci complet basat en això. Amb el desenvolupament de l’escala empresarial, hem d’emmagatzemar les dades de la sessió en redis o mongodb. En aquest moment, hem de modificar les operacions relacionades amb la sessió al mode asíncron.

En teoria, podem modificar cada funció per torns perquè compleixin els requisits de les funcions de què depenen, però això requereix que entenguem tots els mòduls i tinguem la capacitat de modificar-los. Això és completament impossible d'aconseguir quan es desenvolupa una col·laboració multipersonal o quan s'utilitzen mòduls de tercers.

Per tant, tots els mòduls comuns han de proporcionar interfícies de sincronització i sincronització per equilibrar l'equilibri entre asincronia i rendiment. Els desenvolupadors més habituals optaran per proporcionar només la interfície asincronitzada. Això condueix a un desastre de rendiment.

A fibjs, podeu resoldre problemes similars fàcilment i evitar infeccions explícites asíncrones i no controlades:

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 pot utilitzar util.sync per convertir les funcions de devolució de trucada o asincronització en funcions de sincronització i trucar-les directament. D’aquesta manera, podem integrar fàcilment mòduls de diferents paradigmes de programació i transformar-los en paradigmes de sincronització amb costos mínims de desenvolupament, evitant efectivament els desastres causats pel contagi del paradigma.

Comenceu a experimentar

Esteu a punt per començar una experiència de desenvolupament agradable? Comencem, doncs, amb la instal·lació.

👉 [Entorn d' instal·lació i funcionament ]