¿Qué es fibjs?

fibjs es un marco de desarrollo de servidor de aplicaciones diseñado principalmente para el desarrollo de backend web. Se basa en el motor JavaScript de Google v8 y elige una solución de concurrencia diferente de la devolución de llamada tradicional. fibjs usa fibra para aislar la complejidad empresarial causada por las llamadas asincrónicas en la capa del marco, lo que reduce en gran medida la dificultad del desarrollo y reduce los problemas de rendimiento causados ​​por el procesamiento asincrónico frecuente en el espacio del usuario.

Debido a razones históricas, JavaScript se usa principalmente para el procesamiento de la interfaz de usuario de los navegadores. El desarrollo de la interfaz de usuario es un modelo típico de un solo subproceso basado en eventos, por lo que JavaScript también ha formado el procesamiento asíncrono como el principal paradigma de programación.

Con el éxito de JavaScript, más y más personas comenzaron a aplicar JavaScript a otros escenarios. Al mismo tiempo, las personas descubren cada vez más que el procesamiento asíncrono no es la opción más adecuada en muchos escenarios.

Vuelta a lo básico, desarrollo ágil

fibjs utiliza fibra en la capa del marco para aislar la complejidad comercial que generan las llamadas asincrónicas y encapsula el procesamiento asincrónico de io en llamadas sincrónicas más intuitivas. Los ingenieros solo necesitan escribir código de acuerdo con la lógica comercial sincrónica habitual para disfrutar de los beneficios que brindan procesamiento Gran comodidad.

El siguiente fragmento de código se toma de la documentación del módulo 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!');
                    });
                });
        });
});

En fibjs, para realizar el mismo trabajo, el código es el siguiente:

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 busca la brevedad, incluso puede escribir su código de esta manera:

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

Podemos comparar claramente las diferencias provocadas por los dos estilos de programación diferentes. Menos código traerá menos errores Con la reducción del código, la lógica del código será más clara y tanto el desarrollo como el mantenimiento se beneficiarán de ello.

abrazar alta energía

Aunque podemos aumentar fácilmente la velocidad de respuesta al expandir el servidor, el rendimiento debe seguir siendo una de las bases importantes para elegir un marco de desarrollo. Con la introducción de ES7, async se introdujo en JavaScript como un nuevo patrón de desarrollo asíncrono. Sin embargo, cuando disfrutamos del estilo síncrono que trae async, también tenemos que enfrentar su impacto en el rendimiento.

Podemos usar un fragmento de código de prueba para comparar las diferencias de rendimiento provocadas por diferentes estilos de programación:

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

Bajo la última v8, el resultado de este código es el siguiente:

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

Podemos saber claramente a partir de los resultados de la prueba que cuando async se usa ampliamente en el proyecto, el servidor pasará mucho tiempo procesando la llamada y el retorno de las funciones asíncronas. También encontramos esto en algunas pruebas reales de aplicaciones del lado del servidor. Y esta fuerte caída en el rendimiento es completamente inaceptable.

Dado que fibjs usa fibra, puede aprovechar al máximo las características del propio lenguaje JavaScript y maximizar el rendimiento superior de v8. Los ingenieros pueden maximizar fácilmente el rendimiento del servidor.

Elección flexible de paradigma sin ser secuestrado

Elegir usar fibjs no significa que tenga que usar un estilo de desarrollo sincrónico; de hecho, fibjs es compatible con cualquier paradigma de programación asincrónica que haya visto, y puede cambiar de manera flexible entre estilos sincrónicos y asincrónicos.

Ya sea devolución de llamada o asíncrono, existe un defecto fatal, que es el contagio. Siempre que una función sea de devolución de llamada o asíncrona, todas las demás funciones que dependen de ella deben ser de devolución de llamada o asíncronas. Esto traerá enormes costos de desarrollo en el desarrollo de software a gran escala.

Tome un escenario de desarrollo de servidor simple como ejemplo. Al comienzo del proyecto, elegimos la memoria como almacenamiento de datos de sesión. En este momento, podemos usar el método de sincronización para leer y almacenar datos directamente, y desarrollar un negocio completo basado en esto. Con el desarrollo de la escala empresarial, necesitamos almacenar datos de sesión en redis o mongodb. En este momento, necesitamos modificar las operaciones relacionadas con la sesión al modo asíncrono.

En teoría, podemos modificar cada función por turnos para que cumplan con los requisitos de las funciones de las que dependen, pero esto requiere que entendamos completamente todos los módulos y tengamos la capacidad de modificarlos. Esto es completamente imposible cuando se desarrolla en colaboración con varias personas o cuando se utilizan módulos de terceros.

Por lo tanto, todos los módulos comunes deben proporcionar interfaces sincronizadas y asíncronas para equilibrar el equilibrio entre la asincronía y el rendimiento. Los desarrolladores más comunes optarán por proporcionar solo interfaces asíncronas. Provocando así un desastre de rendimiento.

En fibjs, puede resolver fácilmente problemas similares, evitando el contagio descontrolado asíncrono explícito:

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 puede usar util.sync para convertir una función de devolución de llamada o asíncrona en una función de sincronización y llamarla directamente. De esta manera, podemos integrar fácilmente módulos de diferentes paradigmas de programación y transformarlos en paradigmas de sincronización con costos de desarrollo mínimos, evitando de manera efectiva los desastres causados ​​por el contagio de paradigmas.

empieza a experimentar

¿Listo para comenzar una experiencia de desarrollo agradable? Entonces, comencemos con la instalación.

👉 【Entorno de instalación y funcionamiento】