So erstellen Sie eine NodeJS-API ohne Verwendung eines Frameworks

Node.js ist eine Open-Source-JavaScript-Laufzeitumgebung, die auf der v8-Engine von Chrome basiert und es Ihnen ermöglicht, JavaScript-Code außerhalb eines Browsers auszuführen.

Sein Ereignismodell, sein Ökosystem und seine Geschwindigkeit haben Node.js zu einer der gefragtesten und am häufigsten verwendeten Laufzeiten für serverseitige Anwendungen gemacht.

Die meisten Node.js-API-Server verwenden Express oder ein anderes Framework. Sie können aber auch ohne Framework in wenigen Schritten eine einfache Node.js-API erstellen.

Schritt 1: Einrichten Ihrer Entwicklungsumgebung

Erstellen Sie ein Projektverzeichnis und CD hinein, indem Sie Folgendes ausführen:

mkdir nodejs-api
CD nodejs-api

Als nächstes initialisieren npm in Ihrem Projekt, indem Sie Folgendes ausführen:

npm init -y

Diese CRUD-API wird die Verwendung von MongoDB, einer NoSQL-Datenbank, und ihrem beliebten ODM, Mongoose, beinhalten.

Führen Sie zur Installation den folgenden Befehl aus Mungo:

npm Installieren Mungo

Als nächstes erstellen Sie eine

server.js Datei im Stammverzeichnis Ihres Projekts und fügen Sie den folgenden Codeblock hinzu, um einen Server zu erstellen:

konst http= benötigen("http");
konst server = http.createServer((req, res) => {});
server.listen (3000, () => {
Konsole.Protokoll(`Server läuft`);
});

Dieser Codeblock importiert das HTTP-Modul, ein Kernmodul von Node.js. Das http-Modul ermöglicht es Node.js, Daten über HTTP zu übertragen. Dieses Modul enthält die Methoden, die zum Erstellen eines Servers erforderlich sind.

Als nächstes ruft es das http-Modul auf createServer Methode, die eine Instanz eines Servers erstellt und zurückgibt. Das createServer -Methode nimmt eine Callback-Funktion mit einem Request- und Response-Objekt als Parameter entgegen.

Als Nächstes ruft der Code die Hören -Methode auf der zurückgegebenen Serverinstanz. Dadurch kann der Server beginnen, auf dem angegebenen Port auf Datenverkehr zu lauschen. Das Hören -Methode löst einen Callback – das zweite Argument – ​​aus, wenn sie erfolgreich ist.

Erstellen Sie schließlich zwei Verzeichnisse mit dem Namen Strecken und Modelle im Stammverzeichnis Ihres Projekts. Das Strecken Der Ordner enthält die Routing-Logik für Ihre API, während Modell enthält alles, was mit der Datenbank zu tun hat.

Schritt 2: Verbinden Sie Ihre Anwendung mit einer Datenbank

Im server.js, importieren Mungo:

konst Mungo = benötigen("Mungo");

Ruf den verbinden Methode an Mungo und übergeben Sie Ihren MongoDB-URI als Argument:

Mungo.connect ("MongoDB_URI")

Schritt 3: Erstellen eines API-Modells

Erstellen Sie eine CRUD-API für eine einfache Bloganwendung. In deiner Modelle Ordner, erstellen Sie eine blogModel.js file und fügen Sie Ihrer Datei den folgenden Code hinzu:

konst Mungo = benötigen("Mungo");
konst blogSchema = Mungo. Schema({
 Titel: {
 Typ: Schnur,
 erforderlich: [wahr, "Blog muss einen Titel haben"],
 },
 Karosserie: {
 Typ: Schnur,
 erforderlich: [wahr, "Blog muss einen Körper haben"],
 },
});
Modul.Exporte = mongoose.model("Blog", blogSchema);

Der obige Codeblock erstellt ein Mungo-Modell mit zwei Eigenschaften und ordnet sie einer MongoDB-Datenbank zu.

Beide Eigenschaften in diesem Modell haben a Schnur tippe mit erforderlich einstellen Stimmt. Die begleitenden Fehlermeldungen werden angezeigt, wenn ein Anforderungstext keine der Eigenschaften enthält.

Die letzte Zeile erstellt und exportiert ein Mungo-Modell, indem sie die Modell Methode an Mungo. Übergeben Sie den Modellnamen (Bloggen) als erstes Argument und ein Schema (blogSchema) als zweites Argument.

Schritt 4: Implementieren des Routings in Ihrer Anwendung

Ohne die Hilfe von Frameworks wie Express, müssen Sie die Logik manuell erstellen, um jede Anfrage an Ihre API zu verarbeiten.

Erstellen Sie zunächst eine blogRoutes.js Datei in Ihrer Strecken Ordner und importieren Sie dann das Blog-Modell:

konst Blog = benötigen("../models/blogModel");

Erstellen Sie als Nächstes eine asynchrone Router Funktion, passieren erforderlich und res als Parameter und exportieren Sie die Funktion:

konst Router = asynchronFunktion (erforderlich, res) {};
Modul.Exporte = Router;

Diese Funktion enthält Ihre gesamte Routing-Logik.

Als Nächstes implementieren Sie die Routinglogik Route für Route.

GET-Routen

Fügen Sie den folgenden Codeblock zu Ihrer hinzu Router Funktion zur Implementierung der ERHALTEN Route-Handler für Anfragen an /api/blogs:

// ERHALTEN: /api/blogs
if (req.url "/api/blogs"&& erforderl.Methode "ERHALTEN") {
// Alle Blogs erhalten
konst Blogs = erwarten Blog.find();
// einstellen das Status Code undInhalt-Typ
 res.writeHead (200, { "Inhaltstyp": "Anwendung/json" });
// schicke Daten
res.Ende(JSON.stringifizieren(Blogs));
}

Der obige Codeblock überprüft die URL und Methode Eigenschaften des Request-Objekts. Es holt dann alle Blogs aus der Datenbank über die finden Methode nach dem Mungo-Modell (Bloggen).

Als nächstes ruft es die Schreibkopf Methode an res, das Antwortobjekt. Diese Methode sendet einen Antwortheader mit drei Argumenten: einem Statuscode, einer optionalen Statusmeldung und Headern. Das 200 Der Statuscode stellt eine erfolgreiche Antwort dar und der Inhaltstyp für diesen API-Aufruf ist auf festgelegt Anwendung/json.

Schließen Sie schließlich die Anfrage, um sicherzustellen, dass der Server nicht hängt, indem Sie die aufrufen Ende Methode an res. Der Aufruf an JSON.stringify konvertiert die Blogs Objekt in eine JSON-Zeichenfolge und übergeben Sie diese an die Ende -Methode gibt es als Antworttext zurück.

Fügen Sie den folgenden Codeblock zu Ihrer hinzu Router Funktion zur Implementierung der ERHALTEN Routenhandler für eine einzelne Ressource:

// ERHALTEN: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && erforderl.Methode "ERHALTEN") {
Versuchen {
// ID aus URL extrahieren
 const id = req.url.split("/")[3];
// Blog von DB abrufen
konst Blog = erwarten Blog.findById (id);
wenn (Blog) {
 res.writeHead (200, { "Inhaltstyp": "Anwendung/json" });
res.Ende(JSON.stringifizieren(bloggen));
 } anders {
WurfNeuFehler("Blog existiert nicht");
 }
 } Fang (Error) {
 res.writeHead (404, { "Inhaltstyp": "Anwendung/json" });
res.Ende(JSON.stringifizieren({ Botschaft: Error }));
 }
}

Dieser Code verwendet die passen -Methode, die einen Regex-Ausdruck als Argument akzeptiert, um zu prüfen, ob die URL dem Format entspricht: /api/blogs/.

Als nächstes extrahieren Sie die Ich würde Eigentum aus der URL String durch Aufrufen von its Teilt Methode. Diese Methode nimmt ein Muster als Argument (/), teilt die Zeichenfolge basierend auf dem Muster und gibt ein Array zurück. Das dritte Element dieses Arrays ist die Ich würde.

Rufen Sie schließlich das Dokument mit dem Abgleich ab Ich würde aus Ihrer Datenbank. Wenn vorhanden, senden Sie a Antwortcode von 200, schließen Sie die Anforderung und senden Sie den abgerufenen Blog. Wenn es nicht existiert, werfen Sie einen Fehler aus und senden Sie ihn als Antwort im catch-Block.

POST-Route

Fügen Sie den folgenden Codeblock zu Ihrer Router-Funktion hinzu, um die zu implementieren POST Routenhandler:

// POST: /api/blogs/
if (req.url "/api/blogs"&& erforderl.Methode "POST") {
Versuchen {
 Körper = lassen "";
// Auf Datenereignis warten
 anfordern("Daten", (Stück) => {
 body += chunk.toString();
 });
// Zuhören EndeVeranstaltung
 anfordern("Ende", asynchron () => {
// Blog erstellen
Lassen Blog = Neu Blog(JSON.parse (Körper));
// In DB speichern
erwarten blog.save();
 res.writeHead (200, { "Inhaltstyp": "Anwendung/json" });
res.Ende(JSON.stringifizieren(bloggen));
 });
 } Fang (Error) {
Konsole.log (Fehler);
 }
}

Das Request-Objekt implementiert die Node.js ReadableStream Schnittstelle. Dieser Stream sendet a Daten und ein Ende Ereignis, das Ihnen Zugriff auf Daten aus dem Anfragetext gewährt.

Dieser Code wartet auf das Datenereignis und behandelt es, indem er es in eine Zeichenfolge konvertiert und mit der verkettet Karosserie Variable. In dem Ende Event-Handler, es erstellt a Bloggen Instanz mit der geparsten Textzeichenfolge. Anschließend speichert es den neuen Blog, sendet den Statuscode und den Inhaltsheader und schließt die Anfrage.

PUT-Route

Fügen Sie den folgenden Codeblock zu Ihrer Router-Funktion hinzu, um die zu implementieren STELLEN Routenhandler:

// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && erforderl.Methode "STELLEN") {
Versuchen {
// ID aus URL extrahieren
 const id = req.url.split("/")[3];
 Körper = lassen "";
anfordern("Daten", (Stück) => {
 body += chunk.toString();
 });
 anfordern("Ende", asynchron () => {
 // Finden und aktualisierendokumentieren
Lassen aktualisiertBlog = erwarten Blog.findByIdAndUpdate (ID, JSON.parse (Körper), {
Neu: Stimmt,
 });
res.writeHead (200, { "Inhaltstyp": "Anwendung/json" });
res.Ende(JSON.stringifizieren(aktualisiertBlog));
 });
 } Fang (Error) {
Konsole.log (Fehler);
 }
}

Der PUT-Request-Handler ist fast identisch mit dem POST Request-Handler, außer dass er die extrahiert Ich würde Eigentum aus der URL um den entsprechenden Blog zu aktualisieren.

Strecke LÖSCHEN

Fügen Sie den folgenden Codeblock zu Ihrer Router-Funktion hinzu, um Ihre zu implementieren LÖSCHEN Routenhandler:

// LÖSCHEN: /api/blogs/:Ich würde
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && erforderl.Methode "LÖSCHEN") {
Versuchen {
 const id = req.url.split("/")[3];
// Löschen bloggen aus DB
erwarten Blog.findByIdAndDelete (id);
 res.writeHead (200, { "Inhaltstyp": "Anwendung/json" });
 res.end (JSON.stringify({ Nachricht: "Blog erfolgreich gelöscht" }));
 } Fang (Error) {
 res.writeHead (404, { "Inhaltstyp": "Anwendung/json" });
res.Ende(JSON.stringifizieren({ Botschaft: Error }));
 }
}

Dieser Codeblock extrahiert die Ich würde von dem URL, löscht das Dokument mit dem passenden Ich würde, sendet den Statuscode und Header und schließt die Anfrage.

Schließlich importieren Router in deiner server.js Datei und rufen Sie Ihre an Router Funktion, Durchgang erforderlich und res als Argumente:

konst Router = benötigen("./routen/blogRouten");
konst server = http.createServer((req, res) => {
 Router (req, res);
});

Dadurch kann Ihr Server Anfragen abfangen und entsprechend verarbeiten.

Darin finden Sie das abgeschlossene Projekt GitHub-Repository.

Verwenden eines Node.js-Frameworks

Auch wenn es möglich ist, eine Web-API von Hand zu erstellen, kann dies eine schwierige Aufgabe sein. Sie müssen sicherstellen, dass Sie viele Grenzfälle abgedeckt haben und Ihr Code besser fehlerfrei sein sollte.

Im Laufe der Jahre haben Entwickler Frameworks wie ExpressJS, NestJS, Fastify usw. erstellt, um es viel einfacher zu machen.