Lassen Sie uns darüber sprechen, wie Sie mit Node.js einen einfachen HTTP-Server erstellen

Autor：Eve Cole Aktualisierungszeit：2022-06-30 09:29:28

Wie erstelle ich einen HTTP-Server mit NodeJS? Im folgenden Artikel erfahren Sie, wie Sie mit Node einen einfachen HTTP-Server erstellen. Ich hoffe, er hilft Ihnen!

1. Verwenden Sie Node.js, um JavaScript-Skripte direkt auszuführen.

node.js basiert auf der v8 Engine von Chrome , um js Code auszuführen, sodass wir die Browserumgebung loswerden und js -Code direkt in der Konsole ausführen können, wie zum Beispiel das folgende hello world

console.log('hello world');

Sie können ihn direkt über node in der Konsole ausführen

2. Erstellen Sie einen einfachen HTTP-Server.

http http der CommonJS node.js createServer wir require verwenden, um das http http Modul zu importieren Modul, mit dem wir eine http Rückruffunktion erstellen können. Diese Rückruffunktion empfängt zwei Parameter: request und response .

request enthält alle vom Client angeforderten Informationen, z. B. url , header und Anforderungsmethode

Der Anforderungstext wird hauptsächlich

zum

Zurückgeben
response Informationen verwendet. Der response.writeHead kapselt beispielsweise die Header-Informationen und den Statuscode des Rückgabetexts

Für den Antworttext rufen wir response.end() auf. Mit der Funktion createServer können Sie nur ein Server für uns erstellen Wir können die listen server Methode tatsächlich als Server ausführen

listen Der erste Parameter ist die ip Adresse des gebundenen Hosts und der dritte Parameter ist eine Rückruffunktion Wird vom http Modul asynchron aufgerufen, kann die ausgelöste Ausnahme vom ersten Parameter der Rückruffunktion abgerufen werden.

Das Folgende ist ein Beispiel dafür Verwenden des http Moduls zum Erstellen eines einfachen Servers.

const { createServer } = require('http' );
const HOST = 'localhost';
const PORT = '8080';

const server = createServer((req, resp) => {
  // Der erste Parameter ist der Statuscode, den er zurückgibt  
  // und der zweite Parameter sind Antwort-Header-Informationen
  resp.writeHead(200, { 'Content-Type': 'text/plain' });  
  
  console.log('Server funktioniert...');  
  
  // end-Methode aufrufen, um dem Server mitzuteilen, dass die Anfrage erfüllt wurde
  resp.end('hello nodejs http server');
});

server.listen(PORT, HOST, (Fehler) => {  
if (Fehler) {  
  console.log('Etwas stimmt nicht: ', Fehler);   
   zurückkehren;
  }  
  console.log(`Server lauscht auf http://${HOST}:${PORT} ...`);
});

Sie können direkt versuchen, es mit node auszuführen und einen eigenen Server zu erstellen! Nachdem der Server ausgeführt wurde, kann der Browser über http://localhost:8080 auf den Server zugreifen

Sie können es auch mit nodemon ausführen, sodass wir das Programm nicht manuell beenden und

npm i -g nodemon erneut ausführen müssen, wenn sich unser Code ändert.

Es wird empfohlen, es global zu installieren, damit Sie es direkt verwenden können Ohne npx nodemon ist es auch sehr einfach, einfach den node -Befehl in den nodemon -Befehl

nodemon http-server.js

zu ändern

3. Typ-Eingabeaufforderungen hinzufügen

. Wenn wir zuvor createServer und resp Objekte verwendet haben, müssen wir die offizielle node befolgen. Das ist etwas umständlich, aber das spielt keine Rolle kann .d.ts Datei hilft uns, die Syntax-Eingabeaufforderungsfunktion bereitzustellen. Beachten Sie, dass wir ts nicht für die Entwicklung verwenden, sondern nur die Syntax-Eingabeaufforderungsfunktion,

um das Projekt zu initialisieren – npm init -y
install @types/node -- pnpm i @types/node -D
Erstellen Sie die Datei jsconfig.json im Projektverzeichnis, schließen Sie node_modules aus, eine Überprüfung ist nicht erforderlich

{ "compilerOptions": {
    „checkJs“: wahr
  },  
  „exclude“: [„node_modules“, „**/node_modules/*“]
}

Ich frage mich, ob Sie entdeckt haben, dass im obigen Code tatsächlich ein Fehler vorliegt? checkJs können uns dabei helfen, nach Typfehlern zu suchen. Sie können wählen, ob Sie die Prüfung entsprechend Ihren Anforderungen aktivieren möchten. Nach der Aktivierung werden wir sofort über die Nichtübereinstimmung der Parametertypen informiert.

Bewegen Sie zu diesem Zeitpunkt den Mauszeiger über die listen -Methode und Sie können die Signatur der Methode sehen.

Wie Sie sehen, muss der ursprüngliche port vom Typ number sein, aber als wir ihn definiert haben, war er vom Typ string , sodass er nicht übereinstimmte. Ändern Sie ihn einfach in 8080 von number und Sie können die entsprechende api Dokumentation direkt anzeigen Ohne den offiziellen node zu öffnen, hat es lange gedauert, bis ich das Dokument gefunden und überprüft habe.

4. Geben Sie den Antworttext mehrerer Zeichenfolgen zurück

. Unser einfacher http server hat nur einen Satz zurückgegeben. Ist es also möglich, mehrere Sätze zurückzugeben? Dies erfordert, dass die write des resp end Objekts end einmal zurückgegeben wird. Stattdessen können wir den Inhalt mehrmals in den write schreiben Übergeben Sie alle Parameter. Lassen Sie ihn nur die Funktion zum Senden des Antworttexts abschließen.

const { createServer } = require("http");
const HOST = "localhost";
const PORT = 8080;

const server = createServer((req, resp) => {
  resp.writeHead(200, { "Content-Type": "text/plain" });  
  console.log("Server funktioniert...");  
  
  // schreibe ein paar Lorem-Sätze
  resp.write("Lorem ipsum dolor sit amet consectetur adipisicing elit.n");
  resp.write("Omnis eligendi aperiam delectus?n");
  resp.write("Aut, quam quo!n");

  resp.end();
});

server.listen(PORT, HOST, (Fehler) => {
  if (Fehler) {    
  console.log("Etwas stimmt nicht:", Fehler);    
  zurückkehren;
  }  
  console.log(`Server lauscht auf http://${HOST}:${PORT} ...`);
});

Diesmal haben wir drei Sätze geschrieben und der Effekt sieht nun so aus

5. Wenn wir HTML zurückgeben,

können wir nicht nur eine Zeichenfolge an den Browser zurückgeben, sondern auch den Inhalt der html Datei direkt lesen und als Ergebnis an den Browser zurückgeben. Dies erfordert die Verwendung eines anderen integrierten Node.js -Moduls. fs , das die Funktion der Dateioperation bereitstellt. Sie können fs.readFile verwenden, um Dateien asynchron zu lesen, es gibt jedoch kein promise zurück, daher müssen wir einen Rückruf übergeben, um die Operation nach dem Lesen der Datei durchzuführen Sie können auch fs.readFileSync Hier wählen wir asynchrones Lesen

const { createServer } = require("http");
const fs = require("fs");
const HOST = "localhost";

const PORT = 8080;const server = createServer((req, resp) => {
  // den MIME-Typ von text/plain in text/html ändern
  resp.writeHead(200, { "Content-Type": "text/html" });  
  
  // den Inhalt der HTML-Datei lesen
  fs.readFile("index.html", (err, data) => { 
     if (irre) {  
      console.error(      
        „Beim Lesen des Inhalts der HTML-Datei ist ein Fehler aufgetreten:“,
        ähm
      ); wirf irr;
    }    
    console.log("Vorgang erfolgreich!");

    resp.write(data);
    resp.end();
  });
});

server.listen(PORT, HOST, (Fehler) => {
  if (Fehler) {    
  console.log("Etwas stimmt nicht:", Fehler);    
  zurückkehren;
  }  
  console.log(`Server lauscht auf http://${HOST}:${PORT} ...`);
});

Das aktuelle Ergebnis ist wie folgt:

html Hinweis: Hier müssen Sie **Content-Type** des Antwortheaders in **text/html** ändern, um den Browser darüber zu informieren, dass wir den Inhalt der **html** Datei zurückgeben . Wenn Sie weiterhin **text/plain** zurückgegeben wird, verwenden, analysiert der Browser den zurückgegebenen Inhalt nicht, selbst wenn er der **html** Syntax entspricht, wird er nicht analysiert, genau wie im Folgenden:

6. JSON zurückgeben

Wenn wir einen Back-End-Server schreiben müssen, der nur für die Rückgabe von Schnittstellendaten verantwortlich ist, müssen wir Inhalte im json -Format zurückgeben. Ich glaube, Sie sind schlau und wissen, wie man damit umgeht:

Setzen Sie den MIME -Typ auf application/json
resp.write wird die json Zeichenfolge übergeben. Sie können JSON.stringify verwenden, um das Objekt zu verarbeiten und

const { createServer } = require("http"); zurückzugeben.
const HOST = "localhost";
const PORT = 8080;

const server = createServer((req, resp) => { 
 // den MIME-Typ in application/json ändern
  resp.writeHead(200, { "Content-Type": "application/json" });  
  
  // Erstellen Sie JSON-Daten mithilfe eines Objekts  
  const jsonDataObj = {
      Code: 0,    
      Nachricht: „Erfolg“,    
      Daten: {  
          Name: „Plastilin“,      
          Alter: 20,      
          Hobby: „Codieren“,
    },
  };

  resp.write(JSON.stringify(jsonDataObj));
  resp.end();
});

server.listen(PORT, HOST, (Fehler) => {
  if (Fehler) { 
     console.log("Etwas stimmt nicht:", Fehler);    
     zurückkehren;
  }  
  console.log(`Server lauscht auf http://${HOST}:${PORT} ...`);
});

Die Ergebnisse sind wie folgt:

7.

Die Idee der Rückgabe von PDF-Dateien ähnelt der Rückgabe von html Dateien. Diesmal handelt es sich jedoch um einen Prozess, bei dem der MIME Typ des Antwortheaders festgelegt und die Datei zurückgegeben wird etwas anderes. Unsere Idee ist, dies zu tun, während der Server läuft, und sie zurückzugeben, Sie müssen MIME -Typ in application/pdf Um eine pdf pdf zu generieren, müssen Sie eine pdfkit verwenden

pnpm i pdfkit

Zuerst schreiben wir eine Funktion zum Erstellen einer pdf Datei, da zum Erstellen einer pdf -Datei auch einige Schreibvorgänge erforderlich sind. Wir sind uns nicht sicher, wann pdf abgeschlossen sein wird Erhalten Sie eine Antwort, also müssen wir sie asynchron machen und ein promise zurückgeben

/**
 * @description PDF-Datei erstellen */const createPdf = () => {
   neues Versprechen zurückgeben((auflösen, ablehnen) => {
       if (!fs.existsSync("example.pdf")) {      
       // ein PDFDocument-Objekt erstellen      
       const doc = new PDFDocument();
       
       // Schreibstream durch Weiterleiten des PDF-Inhalts erstellen.
       doc.pipe(fs.createWriteStream("example.pdf"));   
        
      // Einige Inhalte zum PDF-Dokument hinzufügen
      doc.fontSize(16).text("Hallo PDF", 100, 100);   
         
      // Den Vorgang zum Generieren einer PDF-Datei abschließen.
      doc.end();
    }

    lösen("Erfolg");
  });
};

Die Pipeline-Operation wird hier verwendet, um den Inhalt PDFDocument Objekts über die Pipeline an den neu erstellten pdf zu übertragen. Wenn die Operation abgeschlossen ist, benachrichtigen wir die Außenwelt über resovle und rufen dann

const

auf

server im Servercode. = createServer(async (req, resp) => {
  // den MIME-Typ in application/pdf ändern
  resp.writeHead(200, { "Content-Type": "application/pdf" });  
  
  // PDF-Datei erstellen  
  warte auf createPdf();  
  
  // Erstellte PDF-Datei lesen
  fs.readFile("example.pdf", (err, data) => {
      if (irre) { 
       console.error(        
        „Beim Lesen des Inhalts der PDF-Datei ist ein Fehler aufgetreten:“,
        ähm
      );      
      wirf irr;
    }    
    console.log("Vorgang erfolgreich!");

    resp.end(data);
  });
});

server.listen(PORT, HOST, (Fehler) => {
  if (Fehler) {
      console.log("Etwas stimmt nicht:", Fehler);    
      zurückkehren;
  }  
  console.log(`Server lauscht auf http://${HOST}:${PORT} ...`);
});

Jetzt kann der Browser die erstellte pdf Datei lesen

8. Die Idee, Audiodateien zurückzugeben,

ist immer noch dieselbe. Lesen Sie eine Audiodatei, senden Sie sie dann über eine Pipeline an das resp Objekt und geben Sie sie zurück

const { createServer } = require("http");
const { stat, createReadStream } = require("fs");
const HOST = "localhost";
const PORT = 8080;

const server = createServer((req, resp) => {
  // den MIME-Typ in audio/mpe ändern
  resp.writeHead(200, { "Content-Type": "audio/mp3" });  
  const mp3FileName = "audio.mp3";

  stat(mp3FileName, (err, stats) => {
    if (stats.isFile()) {      
      const rs = createReadStream(mp3FileName);      
      
      // Den Lesestrom an resp. weiterleiten
      rs.pipe(resp);
    } anders {
      resp.end("mp3-Datei existiert nicht");
    }
  });
});

server.listen(PORT, HOST, (Fehler) => {
  if (Fehler) {    
  console.log("Etwas stimmt nicht:", Fehler);    
  zurückkehren;
  }  
  console.log(`Server lauscht auf http://${HOST}:${PORT} ...`);
});

Der Effekt ist wie folgt

Nach dem Öffnen gibt es eine Schnittstelle zum Abspielen von Audio. Dies ist die Anzeige der von chrome bereitgestellten Audiodateien. Wenn Sie die Konsole öffnen, werden Sie feststellen, dass Audiodateien zurückgegeben werden.

Hinweis: Nachdem der Audiodatei-Stream über die Pipe an **resp** übergeben wurde , muss **resp.end()** nicht aufgerufen werden , da dadurch die gesamte Antwort geschlossen wird und die Audiodatei geöffnet wird nicht verfügbar.

9. Geben Sie die Videodatei zurück.

Die Verarbeitung von Videodateien und Audiodateien ist dieselbe, außer dass MIME Typ in video/mp4 geändert werden muss. Alles andere ist gleich

const { createServer } = require("http");
const { stat, createReadStream } = require("fs");
const HOST = "localhost";
const PORT = 8080;
const server = createServer((req, resp) => {  
// den MIME-Typ in audio/mpe ändern
  resp.writeHead(200, { "Content-Type": "audio/mp4" });  
  const mp4FileName = "video.mp4";

  stat(mp4FileName, (err, stats) => { 
     if (stats.isFile()) {      
     const rs = createReadStream(mp4FileName);      
     // Den Lesestrom an resp. weiterleiten
      rs.pipe(resp);
    } anders {
      resp.end("mp4-Datei existiert nicht");
    }
  });
});

server.listen(PORT, HOST, (Fehler) => { 
 if (Fehler) {    
 console.log("Etwas stimmt nicht:", Fehler);    
 zurückkehren;
  }  
  console.log(`Server lauscht auf http://${HOST}:${PORT} ...`);
});

Zusammenfassend

haben wir gelernt:

JSON
einen
pdf
Node http
js
einen String-Antworttext
html
So
geben Sie Audiodateien zurück:

Obwohl der Inhalt einfach ist, hoffe ich, dass Sie ihn einfach ausprobieren können Das heißt nicht, dass Sie es wissen. Sie werden Ihre eigenen Probleme erst finden, wenn Sie es tatsächlich umsetzen.