Node.js-Routing

In Node.js ist Routing ein wesentlicher Bestandteil der Verarbeitung von HTTP-Anfragen. Es bestimmt, wie Anfragen basierend auf verschiedenen URLs und HTTP-Methoden (wie GET, POST, PUT, DELETE usw.) verteilt werden.

Routing wird häufig verwendet, um Webanwendungen zu erstellen, insbesondere RESTful-APIs.

Node.js selbst verfügt über keine integrierten Routing-Mechanismen, aber es kann durch Middleware-Bibliotheken (wie Express) implementiert werden.

Routing umfasst normalerweise die folgenden Aspekte:

  • URL-Abgleich: Routing-Regeln entsprechend der angeforderten URL abgleichen.
  • HTTP-Methodenabgleich: Routing-Regeln entsprechend der angeforderten HTTP-Methode (GET, POST, PUT, DELETE usw.) abgleichen.
  • Anfrageverarbeitung: Sobald eine passende Routing-Regel gefunden wurde, wird die entsprechende Handler-Funktion aufgerufen, um die Anfrage zu verarbeiten.

In Node.js können wir eine einfache Route über das http-Modul erstellen, wie im folgenden Beispiel:

Beispiel

const http = require('http');

// Server erstellen und Routen definieren
const server = http.createServer((req, res) => {
  const { url, method } = req;

  if (url === '/' && method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Home Page');
  } else if (url === '/about' && method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('About Page');
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('404 Not Found');
  }
});

server.listen(3000, () => {
  console.log('Server is running on http://localhost:3000');
});

Browser-Zugriffhttp://localhost:3000Zeigt Folgendes an:

Browser-Zugriffhttp://localhost:3000/aboutZeigt Folgendes an:

Wenn andere URL-Adressen aufgerufen werden, wird direkt404 Not Found angezeigt。

Für weitere HTTP-Anfragen siehe:HTTP-Tutorial。

Anfrageparameter

Eine vollständige URLhttp://localhost:8888/start?foo=bar&hello=worldenthält den Host, den Pfad und den Query-String.

Um diese Daten zu parsen, können wir dasURL-Objekt und dasquerystring-Modul verwenden.

const myUrl = new URL("http://localhost:8888/start?foo=bar&hello=world");

// 提取路径名
console.log(myUrl.pathname); // 输出: /start

// 提取查询参数
console.log(myUrl.searchParams.get("foo"));   // 输出: bar
console.log(myUrl.searchParams.get("hello")); // 输出: world
myUrl.pathname
          |
          |
        -----
http://localhost:8888/start?foo=bar&hello=world
                                ---       -----
                                 |          |
                                 |          |
           myUrl.searchParams.get("foo")    |
                                            |
                                     myUrl.searchParams.get("hello")

Natürlich können wir auch das querystring-Modul verwenden, um Parameter im POST-Request-Body zu parsen. Dies wird später inNode.js GET/POST-Anfragen vorgestellt..

Alle Request-Daten, die wir benötigen, sind im request-Objekt enthalten, das als erster Parameter an die onRequest()-Callback-Funktion übergeben wird.

Fügen wir nun etwas Logik zur onRequest()-Funktion des http-Moduls hinzu, um den vom Browser angeforderten URL-Pfad herauszufinden:

Code der Datei server.js:

var http = require("http"); var url = require("url"); function start() { function onRequest(request, response) { //Verwende den URL-Konstruktor, um den Anfragepfad zu parsen const pathname = new URL(request.url, `http://${request.headers.host}`).pathname; console.log(`Anfrage für ${pathname} empfangen.`); //Anfragepfad ausgeben //Antwortheader und Antwortinhalt festlegen response.writeHead(200, { "Content-Type": "text/plain" }); //Statuscode und Inhaltstyp festlegen response.write("Hello World"); //Antwortinhalt an den Client senden response.end(); //Antwort beenden } //Erstelle einen Server und lausche auf dem angegebenen Port http.createServer(onRequest).listen(8888); console.log("Server wurde gestartet."); //Startmeldung des Servers ausgeben } //Die start-Funktion zur Verwendung durch andere Module exportieren module.exports.start = start;

Okay, unsere Anwendung kann jetzt verschiedene Anfragen anhand des angeforderten URL-Pfads unterscheiden – das ermöglicht es uns, Routing (noch nicht vollständig) zu verwenden, um Anfragen anhand des URL-Pfads Handlern zuzuordnen.

In der Anwendung, die wir erstellen werden, bedeutet dies, dass Anfragen von /start und /upload mit unterschiedlichem Code behandelt werden können. Später werden wir sehen, wie diese Dinge zusammenpassen.

Jetzt können wir die Route schreiben. Erstellen Sie eine Datei namensrouter.jsund fügen Sie den folgenden Inhalt hinzu:

Code der Datei router.js:

function route(pathname) { console.log("Gleich wird eine Anfrage weitergeleitet für " + pathname); } //Exportiere die route-Funktion exports.route = route;

router.js behandelt die Routing-Logik, definiert und exportiert die route-Funktion, die verwendet wird, um verschiedene Pfade zu behandeln, wenn der Server eine Anfrage empfängt.

Unser Server sollte die Route kennen und sie effektiv nutzen. Wir könnten diese Abhängigkeit natürlich fest im Server codieren, aber Programmiererfahrung in anderen Sprachen sagt uns, dass dies sehr schmerzhaft wäre, also werden wir Dependency Injection verwenden, um das Routing-Modul lose gekoppelt hinzuzufügen.

Erweitern wir zunächst die start()-Funktion des Servers, sodass die route-Funktion als Parameter übergeben werden kann.server.jsDer Dateicode lautet wie folgt:

Code der Datei server.js:

// server.js const http = require("http"); //Importiere das http-Modul von Node.js, um einen Server zu erstellen const { URL } = require("url"); //Importiere den URL-Konstruktor aus dem url-Modul //Definiere und exportiere die start-Funktion, um den Server zu starten function start(route) { //Definiere die onRequest-Funktion, um jede Anfrage zu behandeln function onRequest(request, response) { //Verwende den URL-Konstruktor, um den Anfragepfad zu parsen const pathname = new URL(request.url, `http://${request.headers.host}`).pathname; console.log(`Anfrage für ${pathname} received.`); //Gib den Anfragepfad aus route(pathname); //Rufe die route-Funktion auf, um den Pfad zu behandeln //Setze den Antwort-Header und den Antwort-Inhalt response.writeHead(200, { "Content-Type": "text/plain" }); response.write("Hello World"); response.end(); } //Erstelle einen Server und höre auf dem angegebenen Port http.createServer(onRequest).listen(8888); console.log("Der Server wurde gestartet."); } //Exportiere die start-Funktion zur Verwendung durch andere Module module.exports.start = start;

server.js definiert die Server-Startlogik und ruft die route-Funktion auf, wenn eine Anfrage empfangen wird.

Gleichzeitig erweitern wir index.js entsprechend, sodass die route-Funktion in den Server injiziert werden kann:

Code der Datei index.js:

var server = require("./server"); var router = require("./router"); server.start(router.route);

index.js ist die Einstiegsdatei des Programms, zuständig für das Starten des Servers und das Übergeben des Routing-Moduls an das Server-Modul.

Starten Sie nun die Anwendung (node index.js, merken Sie sich immer diese Kommandozeile), und rufen Sie dann eine URL auf. Sie werden sehen, dass die Anwendung die entsprechenden Informationen ausgibt, was zeigt, dass unser HTTP-Server bereits das Routing-Modul verwendet und den Anfragepfad an die Route übergibt:

$ node index.js
Server has started.

Rufen Sie die folgende URL im Browser aufhttp://localhost:8888/, und der Server sollte die routenbezogene Meldung für den Pfad auf der Konsole ausgeben und eine "Hello World"-Antwort zurückgeben:

Das Backend-Terminal zeigt Zugriffsinformationen an:

Request for / received.
About to route a request for /
Request for /favicon.ico received.
About to route a request for /favicon.ico

Routing mit Express

Express ist ein beliebtes Node.js-Framework, das leistungsstarke Routing-Funktionen bietet.

Weitere Informationen zu Express finden Sie unter:Node.js Express Framework。

Express installieren

Stelle zuerst sicher, dass du Express installiert hast. Falls nicht, kannst du npm verwenden, um es zu installieren:

npm install express

Grundlegendes Routing

Das Folgende ist eine einfache Express-Anwendung, die demonstriert, wie man grundlegendes Routing einrichtet:

Beispiel

const express = require('express');
const app = express();
const port = 3000;

// Definiere eine GET-Route
app.get('/', (req, res) => {
    res.send('Hallo, Welt!');
});

// Definiere eine POST-Route
app.post('/submit', (req, res) => {
    res.send('Formular übermittelt!');
});

// Server starten
app.listen(port, () => {
    console.log(`Server läuft auf http://localhost:${port}`);
});

Dynamisches Routing

Dynamisches Routing ermöglicht es Ihnen, parametrisierte URLs zu verwenden.

Zum Beispiel können Sie eine Route definieren, um/users/:idzu verarbeiten, wobei:idein dynamischer Parameter ist.

app.get('/users/:id', (req, res) => {
    const userId = req.params.id;
    res.send(`User ID: ${userId}`);
});

Routenparameter

Express ermöglicht es Ihnen, Parameter aus der URL zu extrahieren und über das req.params-Objekt darauf zuzugreifen.

Beispiel

app.get('/users/:id', (req, res) => {
    const userId = req.params.id;
    res.send(`Benutzer-ID: ${userId}`);
});

app.get('/search/:query', (req, res) => {
    const query = req.params.query;
    res.send(`Suchanfrage: ${query}`);
});

Abfrageparameter

Abfrageparameter sind Schlüssel-Wert-Paare in der URL, die normalerweise verwendet werden, um zusätzliche Informationen zu übergeben. Sie können über das req.query-Objekt auf Abfrageparameter zugreifen.

app.get('/search', (req, res) => {
    const query = req.query.q;
    res.send(`Search query: ${query}`);
});

Route-Middleware

Route-Middleware sind Funktionen, die vor oder nach der Verarbeitung einer Anfrage ausgeführt werden. Sie können Middleware verwenden, um Aufgaben wie Authentifizierung, Protokollierung und so weiter zu erledigen.

// 日志记录中间件
const logger = (req, res, next) => {
    console.log(`Request Type: ${req.method} ${req.url}`);
    next();
};

// 使用中间件
app.use(logger);

app.get('/', (req, res) => {
    res.send('Hello, World!');
});

Routen-Gruppierung

Um Ihren Code besser zu organisieren, können Sie die Routen-Gruppierung verwenden. Express bietet das Objekt express.Router, mit dem sich modulare, einbindbare Route-Handler erstellen lassen.

Beispiel

const express = require('express');
const app = express();
const port = 3000;

// Router-Instanz erstellen
const userRouter = express.Router();

// Benutzerbezogene Routen definieren
userRouter.get('/', (req, res) => {
    res.send('Liste der Benutzer');
});

userRouter.get('/:id', (req, res) => {
    const userId = req.params.id;
    res.send(`Benutzer-ID: ${userId}`);
});

// Benutzer-Router einbinden
app.use('/users', userRouter);

// Server starten
app.listen(port, () => {
    console.log(`Server läuft auf http://localhost:${port}`);
});

Fortgeschrittene Routing-Techniken

1. Fehlerbehandlung:Sie können eine Fehlerbehandlungs-Middleware definieren, um Fehler in Routen abzufangen und zu behandeln.

app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Something broke!');
});

2. Routenpriorität:Die Reihenfolge, in der Routen definiert werden, bestimmt ihre Priorität; zuerst definierte Routen werden zuerst abgeglichen.

3. Routenbeschränkungen:Sie können Middleware verwenden, um den Zugriff auf bestimmte Routen einzuschränken, beispielsweise nur authentifizierte Benutzer zuzulassen.

Beispiel

const authMiddleware = (req, res, next) => {
    if (req.headers.authorization) {
        next();
    } else {
        res.status(401).send('Unauthorized');
    }
};

app.get('/admin', authMiddleware, (req, res) => {
    res.send('Admin page');
});
Andere Erweiterungen