Praktiken für Hochleistungs-Webanwendungen

einführen

fibjs ist ein hochleistungsfähiges Anwendungsserver-Framework, 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 herkömmlichen Callback. fibjs verwendet Fibers, 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.

Das Design von fibjs legt großen Wert auf Leistung.Die integrierten Netzwerk-IO- und HTTP-Module verwenden ein ereignisgesteuertes, nicht blockierendes I/O-Modell, und Entwickler können problemlos hochzuverlässige Serveranwendungen implementieren. Und da die unterste Schicht von C++ implementiert wird, hat fibjs eine hervorragende Leistung, kann problemlos viele gleichzeitige Zugriffe handhaben und bietet äußerst stabile und zuverlässige Dienste.

Gleichzeitig unterstützt fibjs auch WebSocket, ein auf dem TCP-Protokoll basierendes Vollduplex-Kommunikationsprotokoll, das eine unterbrechungsfreie Verbindung zwischen Browser und Server herstellt, wodurch eine bidirektionale Datenübertragung in Echtzeit realisiert werden kann und kann unterstützen Daten in jedem Format Übertragung. Echtzeit-Kommunikationsanwendungen mit besseren Kommunikationseffekten können durch die Verwendung von WebSocket einfach realisiert werden.

Kurz gesagt, fibjs legt nicht nur Wert auf hohe Leistung und hohe Zuverlässigkeit, sondern bietet auch Echtzeit-Kommunikationsfunktionen wie WebSocket – ein Framework, das sich sehr gut für die Entwicklung von Hochgeschwindigkeits-Webanwendungen eignet.

Erstellen Sie die Entwicklungsumgebung

Bevor wir mit der Entwicklung von fibjs beginnen, müssen wir zuerst die Entwicklungsumgebung vorbereiten. In diesem Kapitel wird erläutert, wie fibjs installiert wird, wie das fibjs-Tool zum Initialisieren des Projekts verwendet wird und wie die integrierte Entwicklungsumgebung der IDE verwendet wird.

Fibjs installieren

Für verschiedene Betriebssysteme ist auch die Art und Weise, fibjs zu installieren, etwas anders.

Für Linux- und macOS-Benutzer kann fibjs mit dem folgenden Befehl installiert werden:

1
curl -s https://fibjs.org/download/installer.sh | sh

Wenn Sie macOS und den Homebrew-Paketmanager verwenden, können Sie ihn auch installieren mit:

1
brew install fibjs

Für Windows-Benutzer müssen Sie das Installationsprogramm von der offiziellen fibjs-Website herunterladen und dann den Anweisungen zur Installation folgen.

Erstellen Sie ein neues Projekt mit fibjs --init

Nach der Installation von fibjs können Sie mit dem fibjs-Tool schnell neue Projekte erstellen. Eine einfache Projektvorlage kann mit dem folgenden Befehl erstellt werden:

1
fibjs --init

Dieser Befehl erstellt eine neue Projektstruktur im aktuellen Verzeichnis, einschließlich package.json, die zum Speichern der grundlegenden Informationen des Projekts und der Abhängigkeitsinformationen verwendet wird.

Schreiben Sie eine Webanwendung

Die Entwicklung von Webanwendungen ist derzeit das am häufigsten verwendete Anwendungsszenario für fibjs. fibjs bietet eine Reihe von Tools und Modulen, mit denen wir Webanwendungen schneller erstellen können.

Schreiben Sie einen HTTP-Server

• Importieren Sie zuerst das http-Modul;
• Instanziieren Sie http.Server und warten Sie auf Anfragen.
• Der Server wird mit der Startfunktion gestartet.

1
2
3
4
5
6
const http = require('http');

const server = new http.Server(8080, (req) => {
    req.response.write('Hello World!');
});
server.start();

Analysieren Sie URL-Parameter und den Anforderungstext

Das Analysieren von URL-Parametern und dem Anforderungstext ist sehr wichtig und wird auf verschiedene Serveranwendungen angewendet. In fibjs können die eingehenden URL-Parameter direkt über req.query geparst werden, während der Anforderungstext über req.body gelesen wird.

1
2
3
4
5
6
7
8
const http = require('http');

const server = new http.Server(8080, (req) => {
    var name = req.query.get('name');
    var msg = name ? `Hello ${name}!` : 'Hello world!';
    req.response.write(msg);
});
server.start();

Implementieren Sie eine Schnittstellenzugriffskontrolle

Das Einschränken des Benutzerzugriffs über Schnittstellen ist ein sehr häufiges Szenario. Unten ist ein einfaches Beispiel.

1
2
3
4
5
6
7
8
9
10
const http = require('http');

const server = new http.Server(8080, (req) => {
    if (req.headers.get('auth') === 'ok') {
        req.response.write('Hello World!');
    } else {
        req.response.write('Access Denied!');
    }
});
server.start();

Routing-Verarbeitung hinzufügen

Routing stellt eines der wichtigsten Konzepte in einer Webanwendung dar. Unter Routing versteht man die Verteilung empfangener Anfragen an Prozessoren nach bestimmten Regeln. In fibjs können Sie Ihr eigenes Routing-Modul schreiben und es an den HTTP-Server binden und dann den URL-Abgleich und die entsprechende Verarbeitung durch benutzerdefiniertes Routing-Parsing durchführen.

1
2
3
4
5
6
7
8
9
const http = require('http');
const { Router } = require('mq');

var router = new Router();
router.get('/hello/:name', function (req, name) {
    req.response.write('hello, ' + name);
});
var svr = new http.Server(8080, router);
svr.start();

Das obige Beispiel lässt sich auch mit einer einfacheren Syntax umsetzen:

1
2
3
4
5
6
7
8
const http = require('http');

var svr = new http.Server(8080, {
    '/hello/:name': function (req, name) {
        req.response.write('hello, ' + name);
    }
});
svr.start();

Fehlerbehandlung und Protokollierung

In fibjs können Sie logische Ausnahmen über den Try-Catch-Block abfangen und sie in die Protokolldatei zum Debugging-Aufzeichnung ausgeben; wenn es sich um eine schwerwiegende Ausnahme handelt, können Sie sie direkt zur Verarbeitung an das obere Framework werfen.

1
2
3
4
5
6
7
8
9
10
const console = require('console');
const http = require('http');

const server = new http.Server(8080, (req) => {
    try {
        // ...
    } catch (e) {
        console.log(e.message, e.stack);
    }
});

domänenübergreifende Anfrage

In fibjs können wir die Methode enableCrossOrigin verwenden, um ursprungsübergreifende Anfragen zuzulassen. Im Folgenden finden Sie einen Beispielcode zum Erstellen eines HTTP-Servers und zum Zulassen von Cross-Origin-Anforderungen:

1
2
3
4
5
6
7
8
const http = require('http');

const server = new http.Server(8080, (req) => {
    req.response.write('Hello World!');
});

server.enableCrossOrigin(); // enable cross domain request
server.start();

Im obigen Beispiel haben wir einen HTTP-Server auf Port 8080 erstellt. Die Methode enableCrossOrigin() erlaubt ursprungsübergreifende Anfragen.

Wenn Sie enableCrossOrigin verwenden, um ursprungsübergreifende Anforderungen zuzulassen, können Sie einen Parameter allowHeaders übergeben, um die ursprungsübergreifenden Header anzugeben, die empfangen werden dürfen. Standardmäßig ist der Wert von allowHeaders Content-Type.

Der Beispielcode lautet wie folgt:

1
2
// enable "Content-Type" and "Authorization" headers in cross domain request
server.enableCrossOrigin("Content-Type, Authorization");

Im obigen Code ist der Wert von allowHeaders „Content-Type, Authorization“, was darauf hinweist, dass der Server den Empfang der beiden domänenübergreifenden Header „Content-Type“ und „Authorization“ zulässt. Wenn die Anfrage andere Header enthält, wird sie vom Server abgelehnt.

Es ist zu beachten, dass wir bei Verwendung der enableCrossOrigin-Einstellung, um den Empfang von domänenübergreifenden Headern zuzulassen, beim Senden von domänenübergreifenden Anforderungen auch den entsprechenden Anforderungsheader setzen müssen, da er sonst ebenfalls vom Server abgelehnt wird.

WebSocket

Das WebSocket-Protokoll ist ein Vollduplex-Kommunikationsprotokoll, das auf dem TCP-Protokoll basiert. Es stellt eine ununterbrochene Verbindung zwischen dem Browser und dem Server her, kann eine Zwei-Wege-Datenübertragung in Echtzeit realisieren und die Datenübertragung in jedem Format unterstützen. In fibjs stellt das WebSocket-Unterstützungsmodul die entsprechende API-Schnittstelle bereit, die die Entwicklung von WebSocket-Server und -Client realisieren kann.

Verwenden Sie das native WebSocket-Modul von fibjs, um die WebSocket-Serverseite zu implementieren

Serverseitig können HTTP-Requests über die Upgrade-Funktion in WebSocket-Verbindungen umgewandelt werden. Beim Erstellen eines HTTP-Serverobjekts können Sie ws.upgrade(callback) verwenden und an die Methode http.start() übergeben, um die HTTP-Anforderung in WebSocket umzuwandeln.

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
var ws = require('ws');
var http = require('http');

var server = new http.Server(8080, {
  '/ws': ws.upgrade(function(conn, req) {
    console.log('a client connected.');

    // listening for message events
    conn.onmessage = function(evt) {
      console.log('received message: ', evt.data);
      // echo the message back to client
      conn.send('Server: ' + evt.data);
    };

    // listening for close events
    conn.onclose = function(code, reason) {
      console.log('closed.');
    };

    // listening for error events
    conn.onerror = function(err) {
      console.log(err);
    };
  })
});

server.start();

Im obigen Beispiel können wir das vom Client gesendete Nachrichtenereignis und das Ereignis zum Schließen der Verbindung zwischen dem Server und dem Client überwachen. Wenn der Server eine Client-Nachricht empfängt, sendet er dieselbe Nachricht an den Client zurück. An dieser Stelle wird eine einfache WebSocket-Punkt-zu-Punkt-Kommunikation realisiert.

Implementieren der Interaktion mit Datenspeichern

Bei der Verwendung von WebSocket zur Kommunikation müssen neben dem einfachen Senden und Empfangen von Nachrichten auch Operationen wie das persistente Speichern und Abfragen von Daten berücksichtigt werden. Zu diesem Zeitpunkt müssen Sie die Datenbank verwenden, und Sie können das integrierte db-Modul von fibjs verwenden, um mit der Datenbank zu interagieren.

Der Beispielcode lautet wie folgt:

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
var ws = require("ws");
var http = require("http");
var db = require("db");

// open a mysql connection
var mysql = db.openMySQL("mysql://root:password@localhost/dbname");

var server = new http.Server(8080, {
  "/ws": ws.upgrade(function(conn, req) {
    console.log("a client connected.");

    // listening for message events
    conn.onmessage = function(evt) {
      console.log("received message: ", evt.data);

      // use execute to query the data
      var rs = mysql.execute("SELECT * FROM user WHERE name=?", evt.data.toString());
      conn.send(JSON.stringify(rs));
    };

    // listening for close events
    conn.onclose = function(code, reason) {
      console.log("closed.");
    };

    // listening for error events
    conn.onerror = function(err) {
      console.log(err);
    };
  })
});

server.start();

Im obigen Beispiel verwenden wir zuerst die openMySQL-Methode des db-Moduls, um ein MySQL-Datenbankverbindungsobjekt mysql zu erstellen, und verwenden dann die execute-Methode, um SQL-Abfragen direkt auszuführen, nachdem wir Nachrichten vom Client abgehört haben, um Datensätze zu erhalten, die die Bedingungen erfüllen. Schließlich werden die Abfrageergebnisse über das WebSocket-Protokoll an den Client zurückgesendet.

Es sollte beachtet werden, dass in der aktuellen Entwicklung Ausnahmebehandlung und Datensicherheit gut gemacht werden müssen.

Zusammenfassend lässt sich sagen, dass wir über das db-Modul in Kombination mit dem WebSocket-Protokoll problemlos mit der Datenbank interagieren können, um hochleistungsfähige Webanwendungen in Echtzeit zu erzielen.

Implementieren Sie die WebSocket-Client-Server-Kommunikation

Auf der Clientseite können Sie eine Verbindung zu einem WebSocket-Server herstellen, indem Sie eine WebSocket-Instanz erstellen und eine URL angeben, und dann Nachrichten an den Server senden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var ws = require('ws');

// create a WebSocket object and connect to ws://localhost:8080/ws
var conn = new ws.Socket('ws://localhost:8080/ws');

// listening for open events
conn.onopen = function() {
  conn.send('hello');
}

// listening for message events
conn.onmessage = function(evt) {
  console.log('received message:', evt.data);
}

// listening for close events
conn.onclose = function(code, reason) {
  console.log('closed.');
}

// listening for error events
conn.onerror = function(err) {
  console.log(err);
}

Im obigen Client-Code erstellen wir eine WebSocket-Instanz und geben deren URL an. Nachdem die Verbindung erfolgreich hergestellt wurde, können wir Nachrichten an den Server senden. Wenn der Server eine Client-Nachricht empfängt, sendet er dieselbe Nachricht an den Client zurück. An dieser Stelle wird eine einfache WebSocket-Punkt-zu-Punkt-Kommunikation realisiert.

Vorteile und Einsatzszenarien von WebSocket

Das WebSocket-Protokoll verfügt über ein typisches bidirektionales Kommunikationsmodell, das es dem Server ermöglicht, Daten aktiv an den Client zu übertragen, und wird häufig verwendet, um Chats, Online-Spiele und andere Gelegenheiten zu implementieren, die Echtzeit und hohe Unmittelbarkeit erfordern. Gegenüber anderen Transportprotokollen hat das WebSocket-Protokoll folgende Vorteile:

• Hohe Echtzeitleistung, unterstützt bidirektionale Kommunikation. • Einfache Protokollspezifikation, einfach zu verwenden. • Kann eine große Anzahl gleichzeitiger Verbindungen handhaben. • Unterstützt lange Verbindungen, wodurch der Zeitverbrauch der Netzwerkübertragung reduziert wird

Zu den häufigsten Nutzungsszenarien von WebSocket gehören Web-Chat, Spielschlachten, Online-Spiele und Instant Messaging usw.

Zusammenfassend lässt sich sagen, dass das WebSocket-Unterstützungsmodul sehr einfach zu implementieren ist und Entwickler schnell ihre eigenen Webanwendungen erstellen können.

Gerätetest

Testframework und Testmethode

Im Softwareentwicklungsprozess ist das Testen ein sehr wichtiges Glied, und Unit-Tests stellen einen wichtigen Teil davon dar. Unit-Tests können effektiv überprüfen, ob der Code dem Design und den Anforderungen entspricht, und Fehler vermeiden, die eingeführt werden, wenn der Code geändert wird. Im Allgemeinen besteht das Prinzip des Komponententests darin, jede Funktion und Methode zu testen, um sicherzustellen, dass die Eingabe und Ausgabe jeder Funktion und Methode korrekt sind.

Ein Testframework ist eine Codebasis zum Schreiben, Ausführen und Verifizieren von Testfällen, die Funktionen wie Testfallverwaltung, Ausführung und Berichterstellung bereitstellt. In JavaScript und Node.js gehören Mocha, Jest und Jasmine zu den beliebten Unit-Testing-Frameworks. In fibjs haben wir auch unser eigenes Testframework, das Testmodul.

Zu den allgemein verwendeten Testmethoden im Unit-Testing-Prozess gehören Black-Box-Tests und White-Box-Tests.

Black-Box-Tests sind eine Testmethode, die nur die Eingabe und Ausgabe einer Funktion berücksichtigt, ohne die Implementierungsdetails innerhalb der Funktion zu berücksichtigen. Black-Box-Tests basieren auf Anforderungsanalyse und Designspezifikationen, durch Testfallanalyse und -ausführung, um festzustellen, ob es Logikfehler, Grenzfehler und Sicherheitsprobleme im Programm gibt. Sein Vorteil ist, dass der Testprozess einfach und die Testergebnisse zuverlässig sind, aber der Nachteil, dass der Test nicht alle Programmpfade abdecken kann.

White-Box-Tests sind eine Testmethode, die die internen Implementierungsdetails von Funktionen berücksichtigt, einschließlich Bedingungsanweisungen, Schleifenanweisungen, Rekursion und Codeabdeckung. Durch diese Tests können Sie mögliche Probleme in der Interaktion zwischen freigegebenen Daten und Code finden. White-Box-Testing hat den Vorteil, dass es alle Programmpfade abdecken kann, hat den Nachteil, dass der Testprozess aufwändiger ist und die Testergebnisse von Umgebung und Implementierungsmethoden beeinflusst werden.

Schreiben Sie Testfälle mit dem Testmodul

In Fibjs können wir das Testmodul verwenden, um Testfälle für Webserver zu schreiben. Hier ist ein einfaches Beispiel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var test = require('test');
test.setup();

var http = require('http');

describe('Web server test', () => {
    it('should return hello world', () => {
        var r = http.get('http://localhost:8080/hello');
        assert.equal(r.statusCode, 200);
        assert.equal(r.data.toString(), 'Hello World');
    });
});

test.run();

In diesem Beispiel verwenden wir die Funktionen "describe" und "it", um das Testmodul bzw. die Testfälle zu definieren, und verwenden die Funktion "assert" für die Bestätigungsverifizierung.

In der Beschreibungsfunktion können wir mehrere it-Funktionen definieren, um jeweils verschiedene Szenarien zu testen. In jeder it-Funktion können wir die http.get-Funktion verwenden, um eine HTTP-GET-Anforderung zu simulieren, die Anforderungsantwort abzurufen und eine Assertion-Verifizierung durchzuführen, wie etwa assertTrue und assertEqual.

Durch das Schreiben von Testfällen können Sie die Korrektheit von Funktionen und Modulen effektiv testen, die Produktqualität sicherstellen und die Wartbarkeit des Codes verbessern.

heißes Update

Hot Update bezieht sich auf die Aktualisierung des Servercodes, ohne den Dienst zu stoppen. Im Prozess der Programmentwicklung ist es für schnelle Iterationen oft notwendig, den Code anzupassen und neue Funktionen hinzuzufügen. Durch die Verwendung von Hot Update kann neuer Code verwendet werden, um die Iterationsarbeit effizienter abzuschließen, ohne den Dienst zu stoppen.

In fibjs können wir das SandBox-Modul verwenden, um reibungslose Hot-Updates zu erreichen. Das SandBox-Modul kann eine sichere Ausführungsumgebung bereitstellen, globale Variablen und andere Funktionen simulieren. Für die spezifische Implementierung beziehen Sie sich bitte auf die folgenden Schritte:

• Laden Sie die zu aktualisierenden Codedateien (z. B. web.js).
• Erstellen Sie über SandBox ein neues Sicherheitsmodul, laden Sie web.js in dieses Modul und generieren Sie ein Sicherheitsmodul. Stellen Sie den Handler des ausgeführten Diensts über das generierte Sicherheitsmodul erneut bereit.
• Der Server verarbeitet weiterhin frühere Anforderungen, und neue Anforderungen werden auf dem neuen Handler bereitgestellt.

Hier ist ein Beispielcode für reibungslose Hot-Updates mit dem SandBox-Modul:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const fs = require('fs');
const http = require('http');
const { SandBox } = require('vm');

let FILE_PATH = './web.js';
let handler = new SandBox().require(FILE_PATH).handler;

const server = new http.Server(8080, handler);

server.start();

fs.watch(FILE_PATH, (event, filename) => {
  handler = new SandBox().require(FILE_PATH).handler;
  server.handler = handler;
  console.log(`[${new Date().toLocaleString()}] server reloaded.`);
});

In diesem Code laden wir beim Programmstart zunächst einmal den Code in web.js, erstellen dann eine SandBox-Instanz und laden den Code in die Instanz. Anschließend haben wir einen neuen HTTP-Server erstellt und die Methode im Handler verwendet, um die Anfrage zu verarbeiten.

Im Code verwenden wir fs.watch, um die Änderungen der Datei web.js zu überwachen. Sobald sich die Datei ändert, laden wir den Code neu und aktualisieren die Implementierung im Handler.

Leistungsoptimierung

Im Entwicklungsprozess müssen wir uns oft Performance-Problemen stellen. Die Optimierung von Code und die Verbesserung der Leistung ist eine der notwendigen Fähigkeiten für Entwickler. In fibjs können wir den CPU-Profiler verwenden, um uns dabei zu helfen, den Ausführungsstatus des Programms zu analysieren und den Code zu optimieren.

In fibjs müssen Sie nur den Befehlszeilenparameter --prof verwenden, um fibjs zu starten, dh Sie können den CPU-Profiler starten (das Standardintervall beträgt 1000 ms). Wenn Sie Analyseprotokolle mit höherer Genauigkeit benötigen, können Sie den Parameter --prof-interval verwenden, um das Protokollintervall festzulegen. Zum Beispiel:

1
2
$ fibjs --prof test.js   # 启动 CPU Profiler，默认以 1000ms 为间隔
$ fibjs --prof --prof-interval=10ms test.js # 启动 CPU Profiler，以 10000us（即 10ms）为间隔

Wenn fibjs die Ausführung beendet, wird im aktuellen Verzeichnis ein Quelldateinamenverzeichnis generiert, das eine Protokolldatei und einige Hilfsdateien enthält. Der Standardname der Protokolldatei lautet fibjs-xxxx.log, wobei xxxx ein Zeitstempel ist. Der Name der Protokolldatei kann mit der Option --log angegeben werden. An dieser Stelle können Sie die generierten Protokolle mit --prof-processverarbeiten :

1
fibjs --prof-process fibjs-xxxx.log prof.svg

Öffnen Sie nach dem Ausführen prof.svg mit einem Browser, um das Flammendiagramm dieses Protokolls anzuzeigen: Sie können klicken, um das Bild in voller Größe anzuzeigen, und im Bild in voller Größe können Sie die Maus verwenden, um detailliertere Informationen anzuzeigen: prof .svg .

Im generierten Flammendiagramm stellt jeder Farbblock einen Aufzeichnungspunkt dar. Je länger der Farbblock, desto öfter wurde er aufgezeichnet; jede Linie stellt eine Anrufstapelschicht dar, und je mehr Schichten, desto mehr Anrufschichten; die Anordnung des Stapels invertiert ist, je niedriger der Farbblock, desto mehr die ursprüngliche Funktion.

Es gibt zwei Arten von Farbblöcken, einer ist rot und der andere blau. Im Profiler von fibjs steht Rot für JavaScript-Operationen und Blau für io-Operationen oder native Operationen. Je nachdem, welches Problem Sie lösen müssen, variieren die Bereiche, auf die Sie sich konzentrieren müssen. Wenn Sie beispielsweise das Problem der hohen CPU-Auslastung lösen müssen, müssen Sie zu diesem Zeitpunkt auf den roten Farbblock achten; und wenn Ihre Anwendung eine geringe CPU-Auslastung hat, aber langsam reagiert, müssen Sie auf die blaue Farbe achten Block. Je größer der Farbblock im oberen Bereich, desto mehr Aufmerksamkeit und Optimierung sind erforderlich.

Wir können versuchen, die Funktionen anzupassen, die mehr CPU-Ressourcen beanspruchen, IO durch asynchrone Methoden implementieren oder den Code beim Schreiben optimieren.

Bereitstellung im Internet

Damit unser Projekt in der Produktion ausgeführt werden kann, müssen wir es kompilieren und bereitstellen. Hier stellen wir vor, wie Sie die Datei „package.json“ verwenden, um die Kompilierung und Bereitstellung zu konfigurieren.

Im Projekt können wir package.json verwenden, um Projektabhängigkeiten zu verwalten, Kompilierung und Bereitstellung zu konfigurieren. Nehmen Sie als Beispiel ein einfaches Beispiel package.json:

1
2
3
4
5
6
7
{
  "name": "my-project",
  "version": "1.0.0",
  "dependencies": {
    "fib-pool": "^1.0.0"
  }
}

Wenn wir das Projekt kompilieren und bereitstellen müssen, müssen wir nur das Projektverzeichnis im Terminal eingeben und dann den folgenden Befehl ausführen:

1
fibjs --install

Dieser Befehl installiert automatisch die Module, von denen das Projekt abhängt. Anschließend können wir das Projekt mit folgendem Befehl starten:

1
fibjs app.js

👉【Domainnamen-Routing】