Express.js beherrschen: Ein tiefer Einblick

Express ist ein äußerst häufig verwendetes Webserver-Anwendungsframework in Node.js. Im Wesentlichen ist ein Framework eine Codestruktur, die sich an bestimmte Regeln hält und zwei Hauptmerkmale aufweist:

• Es kapselt APIs und ermöglicht es Entwicklern, sich mehr auf das Schreiben von Geschäftscode zu konzentrieren.
• Es verfügt über etablierte Prozesse und Standardspezifikationen.

Die Kernfunktionen des Express-Frameworks sind wie folgt:

• Es kann Middleware so konfigurieren, dass sie auf verschiedene HTTP-Anfragen reagiert.
• Es definiert eine Routentabelle zum Ausführen verschiedener Arten von HTTP-Anfrageaktionen.
• Es unterstützt die Übergabe von Parametern an Vorlagen, um eine dynamische Darstellung von HTML-Seiten zu erreichen.

In diesem Artikel wird analysiert, wie Express die Middleware-Registrierung, den nächsten Mechanismus und die Routenbehandlung durch Implementierung einer einfachen LikeExpress-Klasse implementiert.

Express-Analyse

Erkunden wir zunächst die bereitgestellten Funktionen anhand von zwei Express-Codebeispielen:

Beispiel der offiziellen Express-Website „Hello World“.

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

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

app.listen(port, () => {
    console.log(`Example app listening at http://localhost:${port}`);
});

Analyse der Eintragsdatei app.js

Das Folgende ist der Code der Eintragsdatei app.js des Express-Projekts, die vom Express-Generator-Gerüst generiert wurde:

// Handle errors caused by unmatched routes
const createError = require('http-errors');
const express = require('express');
const path = require('path');

const indexRouter = require('./routes/index');
const usersRouter = require('./routes/users');

// `app` is an Express instance
const app = express();

// View engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// Parse JSON format data in post requests and add the `body` field to the `req` object
app.use(express.json());
// Parse the urlencoded format data in post requests and add the `body` field to the `req` object
app.use(express.urlencoded({ extended: false }));

// Static file handling
app.use(express.static(path.join(__dirname, 'public')));

// Register top-level routes
app.use('/', indexRouter);
app.use('/users', usersRouter);

// Catch 404 errors and forward them to the error handler
app.use((req, res, next) => {
    next(createError(404));
});

// Error handling
app.use((err, req, res, next) => {
    // Set local variables to display error messages in the development environment
    res.locals.message = err.message;
    // Decide whether to display the full error according to the environment variable. Display in development, hide in production.
    res.locals.error = req.app.get('env') === 'development'? err : {};
    // Render the error page
    res.status(err.status || 500);
    res.render('error');
});

module.exports = app;

Aus den beiden oben genannten Codesegmenten können wir erkennen, dass die Express-Instanz-App hauptsächlich über drei Kernmethoden verfügt:

1. app.use([path,] callback [, callback...]): Wird zum Registrieren von Middleware verwendet. Wenn der Anforderungspfad mit den festgelegten Regeln übereinstimmt, wird die entsprechende Middleware-Funktion ausgeführt.
   • Pfad: Gibt den Pfad zum Aufrufen der Middleware-Funktion an.
   • Rückruf: Die Rückruffunktion kann verschiedene Formen annehmen. Es kann sich um eine einzelne Middleware-Funktion, eine Reihe von durch Kommas getrennten Middleware-Funktionen, ein Array von Middleware-Funktionen oder eine Kombination aller oben genannten handeln.
2. app.get() und app.post(): Diese Methoden ähneln use(), auch für die Registrierung von Middleware. Sie sind jedoch an HTTP-Anfragemethoden gebunden. Erst bei Verwendung der entsprechenden HTTP-Request-Methode wird die Registrierung der entsprechenden Middleware ausgelöst.
3. app.listen(): Verantwortlich für die Erstellung eines httpServers und die Übergabe der für server.listen() erforderlichen Parameter.

Code-Implementierung

Basierend auf der Analyse der Funktionen des Express-Codes wissen wir, dass sich die Implementierung von Express auf drei Punkte konzentriert:

• Der Registrierungsprozess von Middleware-Funktionen.
• Der zentrale nächste Mechanismus in den Middleware-Funktionen.
• Routenverwaltung mit Schwerpunkt auf Pfadanpassung.

Basierend auf diesen Punkten werden wir unten eine einfache LikeExpress-Klasse implementieren.

1. Grundstruktur der Klasse

Klären Sie zunächst die Hauptmethoden, die diese Klasse implementieren muss:

• use(): Implementiert die allgemeine Middleware-Registrierung.
• get() und post(): Implementieren Sie die Middleware-Registrierung im Zusammenhang mit HTTP-Anfragen.
• listen(): Im Wesentlichen handelt es sich um die listen()-Funktion von httpServer. In der Funktion listen() dieser Klasse wird ein httpServer erstellt, Parameter werden weitergeleitet, Anfragen werden abgehört und die Rückruffunktion (req, res) => {} wird ausgeführt.

Überprüfen Sie die Verwendung des nativen Knoten-httpServers:

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

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

app.listen(port, () => {
    console.log(`Example app listening at http://localhost:${port}`);
});

Dementsprechend ist die Grundstruktur der LikeExpress-Klasse wie folgt:

// Handle errors caused by unmatched routes
const createError = require('http-errors');
const express = require('express');
const path = require('path');

const indexRouter = require('./routes/index');
const usersRouter = require('./routes/users');

// `app` is an Express instance
const app = express();

// View engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// Parse JSON format data in post requests and add the `body` field to the `req` object
app.use(express.json());
// Parse the urlencoded format data in post requests and add the `body` field to the `req` object
app.use(express.urlencoded({ extended: false }));

// Static file handling
app.use(express.static(path.join(__dirname, 'public')));

// Register top-level routes
app.use('/', indexRouter);
app.use('/users', usersRouter);

// Catch 404 errors and forward them to the error handler
app.use((req, res, next) => {
    next(createError(404));
});

// Error handling
app.use((err, req, res, next) => {
    // Set local variables to display error messages in the development environment
    res.locals.message = err.message;
    // Decide whether to display the full error according to the environment variable. Display in development, hide in production.
    res.locals.error = req.app.get('env') === 'development'? err : {};
    // Render the error page
    res.status(err.status || 500);
    res.render('error');
});

module.exports = app;

2. Middleware-Registrierung

Aus app.use([path,] callback [, callback...]) können wir ersehen, dass Middleware ein Array von Funktionen oder eine einzelne Funktion sein kann. Um die Implementierung zu vereinfachen, verarbeiten wir die Middleware einheitlich als Funktionsarray. In der LikeExpress-Klasse können die drei Methoden use(), get() und post() alle die Middleware-Registrierung implementieren. Lediglich die ausgelöste Middleware variiert aufgrund unterschiedlicher Anforderungsmethoden. Also überlegen wir:

• Abstraktion einer allgemeinen Middleware-Registrierungsfunktion.
• Erstellen von Arrays von Middleware-Funktionen für diese drei Methoden, um die Middleware entsprechend verschiedenen Anforderungen zu speichern. Da use() eine allgemeine Middleware-Registrierungsmethode für alle Anfragen ist, ist das Array, das die use()-Middleware speichert, die Vereinigung der Arrays für get() und post().

Middleware-Warteschlangenarray

Das Middleware-Array muss in einem öffentlichen Bereich platziert werden, damit Methoden in der Klasse leicht darauf zugreifen können. Also fügen wir das Middleware-Array in die Konstruktorfunktion „constructor()“ ein.

const http = require("http");
const server = http.createServer((req, res) => {
    res.end("hello");
});
server.listen(3003, "127.0.0.1", () => {
    console.log("node service started successfully");
});

Middleware-Registrierungsfunktion

Middleware-Registrierung bedeutet, dass die Middleware im entsprechenden Middleware-Array gespeichert wird. Die Middleware-Registrierungsfunktion muss die eingehenden Parameter analysieren. Der erste Parameter kann eine Route oder Middleware sein. Daher muss zunächst festgestellt werden, ob es sich um eine Route handelt. Wenn ja, geben Sie es so aus, wie es ist. Andernfalls ist die Standardroute die Root-Route und konvertiert dann die verbleibenden Middleware-Parameter in ein Array.

const http = require('http');

class LikeExpress {
    constructor() {}

    use() {}

    get() {}

    post() {}

    // httpServer callback function
    callback() {
        return (req, res) => {
            res.json = function (data) {
                res.setHeader('content-type', 'application/json');
                res.end(JSON.stringify(data));
            };
        };
    }

    listen(...args) {
        const server = http.createServer(this.callback());
        server.listen(...args);
    }
}

module.exports = () => {
    return new LikeExpress();
};

Implementierung von use(), get() und post()

Mit der allgemeinen Middleware-Registrierungsfunktion register() ist es einfach, use(), get() und post() zu implementieren, indem Sie die Middleware einfach in den entsprechenden Arrays speichern.

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

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

app.listen(port, () => {
    console.log(`Example app listening at http://localhost:${port}`);
});

3. Routenanpassungsverarbeitung

Wenn der erste Parameter der Registrierungsfunktion eine Route ist, wird die entsprechende Middleware-Funktion nur ausgelöst, wenn der Anforderungspfad mit der Route übereinstimmt oder deren Unterroute ist. Wir benötigen also eine Routen-Matching-Funktion, um das Middleware-Array der passenden Route entsprechend der Anforderungsmethode und dem Anforderungspfad zu extrahieren, damit die nachfolgende callback()-Funktion ausgeführt werden kann:

// Handle errors caused by unmatched routes
const createError = require('http-errors');
const express = require('express');
const path = require('path');

const indexRouter = require('./routes/index');
const usersRouter = require('./routes/users');

// `app` is an Express instance
const app = express();

// View engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// Parse JSON format data in post requests and add the `body` field to the `req` object
app.use(express.json());
// Parse the urlencoded format data in post requests and add the `body` field to the `req` object
app.use(express.urlencoded({ extended: false }));

// Static file handling
app.use(express.static(path.join(__dirname, 'public')));

// Register top-level routes
app.use('/', indexRouter);
app.use('/users', usersRouter);

// Catch 404 errors and forward them to the error handler
app.use((req, res, next) => {
    next(createError(404));
});

// Error handling
app.use((err, req, res, next) => {
    // Set local variables to display error messages in the development environment
    res.locals.message = err.message;
    // Decide whether to display the full error according to the environment variable. Display in development, hide in production.
    res.locals.error = req.app.get('env') === 'development'? err : {};
    // Render the error page
    res.status(err.status || 500);
    res.render('error');
});

module.exports = app;

Dann extrahieren Sie in der Rückruffunktion callback() des httpServers die Middleware, die ausgeführt werden muss:

const http = require("http");
const server = http.createServer((req, res) => {
    res.end("hello");
});
server.listen(3003, "127.0.0.1", () => {
    console.log("node service started successfully");
});

4. Umsetzung des nächsten Mechanismus

Die Parameter der Express-Middleware-Funktion sind req, res und next, wobei next eine Funktion ist. Nur durch den Aufruf können die Middleware-Funktionen nacheinander ausgeführt werden, ähnlich wie bei next() im ES6 Generator. In unserer Implementierung müssen wir eine next()-Funktion mit den folgenden Anforderungen schreiben:

• Extrahieren Sie jedes Mal eine Middleware aus dem Middleware-Warteschlangen-Array der Reihe nach.
• Übergeben Sie die next()-Funktion an die extrahierte Middleware. Da das Middleware-Array öffentlich ist, wird bei jeder Ausführung von next () die erste Middleware-Funktion im Array herausgenommen und ausgeführt, wodurch der Effekt einer sequentiellen Ausführung der Middleware erzielt wird.

const http = require('http');

class LikeExpress {
    constructor() {}

    use() {}

    get() {}

    post() {}

    // httpServer callback function
    callback() {
        return (req, res) => {
            res.json = function (data) {
                res.setHeader('content-type', 'application/json');
                res.end(JSON.stringify(data));
            };
        };
    }

    listen(...args) {
        const server = http.createServer(this.callback());
        server.listen(...args);
    }
}

module.exports = () => {
    return new LikeExpress();
};

Express-Code

constructor() {
    // List of stored middleware
    this.routes = {
        all: [], // General middleware
        get: [], // Middleware for get requests
        post: [], // Middleware for post requests
    };
}

Leapcell: Die serverlose Plattform der nächsten Generation für Webhosting, Async-Aufgaben und Redis

Lassen Sie mich abschließend eine Plattform vorstellen, die sich sehr gut für die Bereitstellung von Express eignet: Leapcell.

Leapcell ist eine serverlose Plattform mit den folgenden Eigenschaften:

1. Mehrsprachige Unterstützung

• Entwickeln Sie mit JavaScript, Python, Go oder Rust.

2. Stellen Sie unbegrenzt viele Projekte kostenlos bereit

• Bezahlen Sie nur für die Nutzung – keine Anfragen, keine Gebühren.

3. Unschlagbare Kosteneffizienz

• Pay-as-you-go ohne Leerlaufgebühren.
• Beispiel: 25 $ unterstützen 6,94 Millionen Anfragen bei einer durchschnittlichen Antwortzeit von 60 ms.

4. Optimierte Entwicklererfahrung

• Intuitive Benutzeroberfläche für mühelose Einrichtung.
• Vollautomatische CI/CD-Pipelines und GitOps-Integration.
• Echtzeitmetriken und Protokollierung für umsetzbare Erkenntnisse.

5. Mühelose Skalierbarkeit und hohe Leistung

• Automatische Skalierung zur problemlosen Bewältigung hoher Parallelität.
• Kein Betriebsaufwand – konzentrieren Sie sich nur auf das Bauen.

Erfahren Sie mehr in der Dokumentation!

Leapcell Twitter: https://x.com/LeapcellHQ

Das obige ist der detaillierte Inhalt vonExpress.js beherrschen: Ein tiefer Einblick. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!