So erstellen Sie eine NodeJS-API ohne die Verwendung eines Frameworks

So erstellen Sie eine NodeJS-API ohne die 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.





MAKEUSEOF VIDEO DES TAGES

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 install mongoose

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:

const http = require("http"); 
const server = http.createServer((req, res) => {}); 
  
server.listen(3000, () => { 
  console.log(`Server is running`); 
});

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 :

const mongoose = require("mongoose");

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

mongoose.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:

const mongoose = require("mongoose"); 
const blogSchema = mongoose.Schema({ 
  title: { 
    type: String, 
    required: [true, "Blog must have a title"], 
  }, 
  body: { 
    type: String, 
    required: [true, "Blog must have a body"], 
  }, 
}); 
module.exports = 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.

Dateityp-Symbol ändern Windows 10

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 ( blogZeitplan ) 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:

const Blog = require("../models/blogModel");

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

const router = async function (req, res) {}; 
module.exports = router;

Diese Funktion enthält Ihre gesamte Routing-Logik.

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

Dieses Zubehör wird möglicherweise nicht vom iPhone unterstützt

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 :

//  GET: /api/blogs 
if (req.url === "/api/blogs" && req.method === "GET") { 
    // get all blogs 
    const blogs = await Blog.find(); 
  
    // set the status code and content-type 
    res.writeHead(200, { "Content-Type": "application/json" }); 
  
    // send data 
    res.end(JSON.stringify(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:

// GET: /api/blogs/:id 
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "GET") { 
    try { 
        // extract id from url 
        const id = req.url.split("/")[3]; 
  
        // get blog from DB 
        const blog = await Blog.findById(id); 
  
        if (blog) { 
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(blog)); 
        } else { 
            throw new Error("Blog does not exist"); 
        } 
    } catch (error) { 
        res.writeHead(404, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: 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" && req.method === "POST") { 
    try { 
        let body = ""; 
  
        // Listen for data event 
        req.on("data", (chunk) => { 
            body += chunk.toString(); 
        }); 
  
        // Listen for end event 
        req.on("end", async () => { 
            // Create Blog 
            let blog = new Blog(JSON.parse(body)); 
  
            // Save to DB 
            await blog.save(); 
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(blog)); 
        }); 
    } catch (error) { 
        console.log(error); 
    } 
}

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]+)/) && req.method === "PUT") { 
    try { 
        // extract id from url 
        const id = req.url.split("/")[3]; 
        let body = ""; 
  
        req.on("data", (chunk) => { 
            body += chunk.toString(); 
        }); 
        req.on("end", async () => { 
            // Find and update document 
            let updatedBlog = await Blog.findByIdAndUpdate(id, JSON.parse(body), { 
                new: true, 
            }); 
  
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(updatedBlog)); 
        }); 
    } catch (error) { 
        console.log(error); 
    } 
}

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:

// DELETE: /api/blogs/:id 
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "DELETE") { 
    try { 
        const id = req.url.split("/")[3]; 
         
       // Delete blog from DB 
        await Blog.findByIdAndDelete(id); 
        res.writeHead(200, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: "Blog deleted successfully" })); 
    } catch (error) { 
        res.writeHead(404, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: 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:

const router = require("./routes/blogRoutes"); 
  
const 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.