Was ist fibjs?
fibjs ist ein Anwendungsserver-Entwicklungsframework, das hauptsächlich für die Entwicklung von Web-Backends entwickelt wurde. Es basiert auf der JavaScript-Engine von Google v8 und wählt eine andere Concurrency-Lösung als den traditionellen Callback. fibjs verwendet Fiber, um die durch asynchrone Aufrufe verursachte Geschäftskomplexität auf der Framework-Ebene zu isolieren, wodurch die Entwicklungsschwierigkeiten erheblich reduziert und die Leistungsprobleme reduziert werden, die durch häufige asynchrone Verarbeitung im Benutzerbereich verursacht werden.
Aus historischen Gründen wird JavaScript hauptsächlich für die UI-Verarbeitung von Browsern verwendet.Die UI-Entwicklung ist ein typisches Single-Threaded-Ereignis-gesteuertes Modell, sodass JavaScript auch die asynchrone Verarbeitung als das Hauptprogrammierparadigma herausgebildet hat.
Mit dem Erfolg von JavaScript begannen immer mehr Menschen, JavaScript auf andere Szenarien anzuwenden. Gleichzeitig stellen die Menschen 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 Fiber in der Framework-Schicht, um die durch asynchrone Aufrufe verursachte Geschäftskomplexität zu isolieren, und kapselt die asynchrone Verarbeitung von io in intuitivere synchrone Aufrufe. Ingenieure müssen nur Code gemäß der üblichen synchronen Geschäftslogik schreiben, um die Vorteile von asynchron zu nutzen Verarbeitung Hoher Komfort.
Das folgende Code-Snippet stammt aus der Dokumentation für das mysql-Modul:
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
32conn.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 sieht der Code wie folgt aus, um die gleiche Arbeit zu erledigen:
1
2
3
4
5
6conn.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 es Ihnen um die Kürze geht, können Sie Ihren Code sogar so schreiben:
1
2
3
4conn.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 die beiden unterschiedlichen Programmierstile verursacht werden, deutlich vergleichen. Weniger Code bringt weniger Fehler Mit der Codereduzierung wird die Logik des Codes klarer und sowohl die Entwicklung als auch die Wartung profitieren davon.
Umarme hohe Energie
Obwohl wir die Reaktionsgeschwindigkeit durch eine Erweiterung des Servers leicht erhöhen können, sollte die Leistung dennoch eine der wichtigen Grundlagen für die Auswahl eines Entwicklungsframeworks sein. Mit der Einführung von ES7 wurde Async als neues asynchrones Entwicklungsmuster in JavaScript eingeführt. Wenn wir jedoch den synchronen Stil von async genießen, müssen wir uns auch seinen 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
39var 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 sieht das Ergebnis dieses Codes wie folgt aus:
1
2
3async: 0.539ms
callback: 0.221ms
sync: 0.061ms
Wir können aus den Testergebnissen eindeutig erkennen, dass der Server viel Zeit mit der Verarbeitung des Aufrufs und der Rückgabe von asynchronen Funktionen verbringt, wenn Async im Projekt weit verbreitet ist. Wir haben dies auch in einigen aktuellen Tests serverseitiger Anwendungen festgestellt. Und dieser starke Leistungsabfall ist völlig inakzeptabel.
Da fibjs Fiber verwendet, kann es die Eigenschaften der JavaScript-Sprache selbst voll ausnutzen und die überlegene Leistung von v8 maximieren. Techniker können die Leistung des Servers ganz einfach maximieren.
Flexible Paradigmenwahl ohne Entführung
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 gesehen haben, und Sie können flexibel zwischen synchronen und asynchronen Stilen wechseln.
Ob Callback oder Async, es gibt 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 bei der groß angelegten Softwareentwicklung mit sich bringen.
Nehmen Sie als Beispiel ein einfaches Serverentwicklungsszenario. Zu Beginn des Projekts haben wir den Arbeitsspeicher als Session-Datenspeicher gewählt, jetzt können wir mit der Sync-Methode Daten direkt auslesen und speichern und darauf aufbauend ein komplettes Business entwickeln. Mit der Entwicklung von Business Scale 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 modifizieren, damit sie die Anforderungen der Funktionen erfüllen, von denen sie abhängen, aber dies erfordert, dass wir alle Module vollständig verstehen und in der Lage sind, sie zu modifizieren. Dies ist bei der kollaborativen Entwicklung durch mehrere Personen oder bei der Verwendung von Modulen von Drittanbietern völlig unmöglich.
Daher müssen alle gängigen Module sowohl synchrone als auch asynchrone Schnittstellen bereitstellen, um das Gleichgewicht zwischen Asynchronität und Leistung auszugleichen. Gewöhnlichere Entwickler werden sich dafür entscheiden, nur asynchrone Schnittstellen bereitzustellen. Dadurch kommt es zu einem Performance-Desaster.
In fibjs können Sie ähnliche Probleme leicht lösen und eine explizite asynchrone unkontrollierte Ansteckung vermeiden:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17var 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 eine Callback- oder Async-Funktion in eine Sync-Funktion umzuwandeln und direkt aufzurufen. Auf diese Weise können wir Module verschiedener Programmierparadigmen einfach integrieren und sie mit minimalen Entwicklungskosten in Synchronisierungsparadigmen umwandeln, wodurch durch Paradigmenansteckung verursachte Katastrophen effektiv vermieden werden.
anfangen zu erleben
Sind Sie bereit, eine angenehme Entwicklungserfahrung zu beginnen? Beginnen wir also mit der Installation.