Detaillierte Erklärung, wie zwei Node.js-Prozesse kommunizieren

Vorwort

Wie kommunizieren zwei Node.js-Prozesse miteinander? Hier gibt es zwei Szenarien:

1. Kommunikation zwischen zwei Node.js-Prozessen auf verschiedenen Computern
2. Kommunikation zwischen zwei Node.js-Prozessen auf demselben Computer

Im ersten Szenario wird für die Kommunikation normalerweise TCP oder HTTP verwendet, während es im zweiten Szenario zwei Unterszenarien gibt:

1. Der Node.js-Prozess kommuniziert mit dem von ihm erstellten Node.js-Unterprozess
2. Der Node.js-Prozess kommuniziert mit einem anderen, nicht verwandten Node.js-Prozess

Ersteres kann den integrierten IPC-Kommunikationskanal verwenden, und letzteres kann eine benutzerdefinierte Pipeline verwenden, die im Folgenden ausführlich beschrieben wird:

Kommunikation zwischen zwei Node.js-Prozessen auf verschiedenen Computern

Um kommunizieren zu können, müssen wir zunächst herausfinden, wie wir die Prozesse im Netzwerk identifizieren können. Die IP-Adresse der Netzwerkschicht kann den Host im Netzwerk eindeutig identifizieren, während das Protokoll und der Port der Transportschicht die Anwendung (den Prozess) im Host eindeutig identifizieren können. Auf diese Weise kann der Prozess des Netzwerks mithilfe des Tripletts (IP-Adresse, Protokoll, Port) identifiziert werden.

Verwenden von TCP-Sockets

TCP-Socket ist eine auf dem TCP/IP-Protokoll basierende Kommunikationsmethode, die die Kommunikation zwischen Prozessen auf über das Netzwerk verbundenen Computern ermöglicht. Einer wird als Server und der andere als Client verwendet. Der server.js-Code lautet wie folgt:

const net = erfordern('net')
const server = net.createServer(socket => {
  console.log('Socket verbunden')
  socket.on('schließen', () => console.log('Socket getrennt'))
  socket.on('Fehler', err => Konsole.Fehler(Fehlernachricht))
  socket.on('Daten', Daten => {
    console.log(`empfangen: ${data}`)
    socket.schreiben(Daten)
    console.log(`senden: ${data}`)
  })
})
server.listen(8888)

client.js-Code:

const net = erfordern('net')
const client = net.connect(8888, '192.168.10.105')

client.on('connect', () => console.log('verbunden.'))
client.on('Daten', Daten => console.log(`empfangen: ${data}`))
client.on('end', () => console.log('getrennt.'))
client.on('Fehler', err => Konsole.Fehler(Fehlernachricht))

setzeIntervall(() => {
  const msg = "hallo"
  console.log(`senden: ${msg}`)
  client.write(Nachricht)
}, 3000)

Wirkung der Operation:

$ Knoten server.js
Client verbunden
empfangen: hallo
sende: hallo

$ Knoten client.js
Mit dem Server verbinden
sende: hallo
empfangen: hallo

Verwenden des HTTP-Protokolls

Da das HTTP-Protokoll ebenfalls auf TCP basiert, unterscheidet sich diese Methode aus Kommunikationssicht im Wesentlichen nicht, sie kapselt lediglich das Protokoll der oberen Schicht. Der server.js-Code lautet:

const http = erfordern('http').
http.createServer((req, res) => res.end(req.url)).listen(8888)

client.js-Code:

const http = erfordern('http').
const Optionen = {
  Hostname: '192.168.10.105',
  Port: 8888,
  Pfad: '/hallo',
  Methode: 'GET',
}
const req = http.request(Optionen, res => {
  Konsole.log(`statusCode: ${res.statusCode}`)
  res.on('Daten', d => verarbeiten.stdout.write(d))
})
req.on('Fehler', Fehler => Konsole.Fehler(Fehler))
erforderlich.ende()

Wirkung der Operation:

$ Knoten server.js
URL /Hallo

$ Knoten client.js
Statuscode: 200
Hallo

Kommunikation zwischen zwei Node.js-Prozessen auf demselben Computer

Obwohl Netzwerk-Sockets auch für die Interprozesskommunikation auf demselben Host verwendet werden können (über die Loopback-Adresse 127.0.0.1), erfordert diese Methode das Durchlaufen des Netzwerkprotokollstapels, das Verpacken und Entpacken, das Berechnen von Prüfsummen, das Verwalten von Sequenznummern und Antworten usw., was für die Netzwerkkommunikation ausgelegt ist. Zwei Prozesse auf demselben Computer können eine effizientere Kommunikationsmethode haben, nämlich IPC (Inter-Process Communication). Die spezifische Implementierungsmethode unter Unix ist Unix Domain Socket, eine Methode zur Kommunikation zwischen dem Server und dem Client über eine lokal geöffnete Socket-Datei. Im Gegensatz zur TCP-Kommunikation werden während der Kommunikation lokale Dateien angegeben, sodass keine Domänenauflösung und keine externe Kommunikation durchgeführt werden. Daher ist es schneller als TCP und die Übertragungsgeschwindigkeit auf demselben Host ist doppelt so hoch wie bei TCP.

Integrierte IPC-Kanäle verwenden

Wenn Sie mit einem von Ihnen erstellten untergeordneten Prozess kommunizieren möchten, ist dies sehr praktisch. Die Fork-Methode im Modul child_process verfügt über einen eigenen Kommunikationsmechanismus, sodass Sie nicht auf die zugrunde liegenden Details achten müssen. Beispielsweise der Code des übergeordneten Prozesses parent.js:

const fork = erfordern("untergeordneter_Prozess").fork
const path = require("Pfad")
const child = fork(path.resolve("child.js"), [], { stdio: "inherit" });
child.on("Nachricht", (Nachricht) => {
  console.log("Nachricht vom Kind:", Nachricht)
  kind.senden("hallo")
})

Child-Prozess-Code child.js:

process.on("Nachricht", (Nachricht) => {
  console.log("Nachricht vom übergeordneten Element:", Nachricht);
})

if (prozess.senden) {
  setInterval(() => process.send("hallo"), 3000)
}

Der Operationseffekt ist wie folgt:

$ Knoten übergeordnetes Element.js
Nachricht vom Kind: Hallo
Nachricht vom Elternteil: Hallo
Nachricht vom Kind: Hallo
Nachricht vom Elternteil: Hallo

Verwenden einer benutzerdefinierten Pipeline

Wenn es zwei unabhängige Node.js-Prozesse gibt, wie richtet man einen Kommunikationskanal ein? Unter Windows können Sie benannte Pipes (Named PIPE) verwenden, und unter Unix können Sie Unix-Domain-Sockets verwenden, einen als Server und den anderen als Client. Der Code von server.js lautet wie folgt:

const net = erfordern('net')
const fs = erfordern('fs')

const pipeFile = Prozess.Plattform === 'win32' ? '\\\\.\\pipe\\mypip' : '/tmp/unix.sock'

const server = net.createServer(Verbindung => {
  console.log('Socket verbunden.')
  Verbindung.ein('schließen', () => console.log('getrennt.'))
  Verbindung.ein('Daten', Daten => {
    console.log(`empfangen: ${data}`)
    Verbindung.schreiben(Daten)
    console.log(`senden: ${data}`)
  })
  Verbindung.ein('Fehler', err => Konsole.Fehler(Fehlernachricht))
})

versuchen {
  fs.unlinkSync(pipeFile)
} Fang (Fehler) {}

server.listen(pipeFile)

Der client.js-Code lautet wie folgt:

const net = erfordern('net')

const pipeFile = Prozess.Plattform === 'win32' ? '\\\\.\\pipe\\mypip' : '/tmp/unix.sock'

const-Client = net.connect(pipeFile).
client.on('connect', () => console.log('verbunden.'))
client.on('Daten', Daten => console.log(`empfangen: ${data}`))
client.on('end', () => console.log('getrennt.'))
client.on('Fehler', err => Konsole.Fehler(Fehlernachricht))

setzeIntervall(() => {
  const msg = "hallo"
  console.log(`senden: ${msg}`)
  client.write(Nachricht)
}, 3000)

Wirkung der Operation:

$ Knotenserver.js 
Buchse angeschlossen.
empfangen: hallo
sende: hallo

$ Knoten client.js
verbunden.
sende: hallo
empfangen: hallo

Zusammenfassen

Dies ist das Ende dieses Artikels über die Kommunikation zweier Node.js-Prozesse. Weitere Informationen zur Kommunikation zweier Node.js-Prozesse finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!