1. Öffnungsanalyse
Lassen Sie uns ab heute ausführlich in bestimmten Modulen lernen. Dieser Artikel ist der dritte Artikel in dieser Serie. Die ersten beiden Artikel basieren hauptsächlich auf Theorie. Ich glaube, dass im Studium der ersten beiden Artikel,
Ich habe auch ein grundlegendes Verständnis von NodeJs, es ist okay! ! ! Streik, während das Eisen heiß ist, tragen wir weiterhin Nodejs bis zum Ende. Nun, ohne viel Unsinn zu sagen, gehen Sie direkt zum heutigen Thema "Netzmodul". Wie soll das "Netz" das verstehen?
Wofür ist es? ( Net kann verwendet werden, um Socket-Server oder Socket-Clients zu erstellen. Die beiden grundlegendsten Module für die NodeJS-Datenkommunikation sind NET und HTTP. Ersteres ist eine TCP-basierte Kapselung, während letzteres im Wesentlichen eine TCP-Schicht durchgeführt wurde, aber eine Menge Datenkapselung, die wir als Präsentationsschicht betrachten.)
Hier beziehen wir uns auf den Quellcode in NodeJS "http.js":
Aus der Abbildung ist es nicht schwer zu erkennen, dass HTTPserver die Nettoklasse erbt, Kommunikationsfunktionen hat und mehr Datenkapselung durchgeführt hat, die wir als fortgeschrittenere Repräsentationsschicht betrachten.
Erweitertes Wissen (Folgendes ist der Quellcode "Erben"):
Die Codekopie lautet wie folgt:
exports.inherits = function (ctor, superctor) {
ctor.super_ = superctor;
ctor.prototype = Object.create (Superctor.Prototype, {
Konstruktor: {
Wert: ctor,
Aufzählbar: Falsch,
Beschreibbar: wahr,
Konfigurierbar: True
}
});
};
Die Funktion besteht darin, Erbschaft und Wiederverwendung zu realisieren.
Ich habe gerade einen kurzen Überblick gegeben, der einige häufig verwendete Konzepte enthält. Hier ist eine kurze Einführung in die Popularisierung von Konzepten:
(1) TCP/IP ---------- TPC/IP-Protokoll ist ein Transportschichtprotokoll, das hauptsächlich die Übertragung von Daten im Netzwerk löst.
(2), Socket ----- Socket ist die Einkapselung und Anwendung des TCP/IP-Protokolls (Programmebene).
(3), HTTP ------ HTTP ist ein Anwendungsschichtprotokoll, das hauptsächlich das Wickeln von Daten löst.
(4) Das siebenschichtige Netzwerkmodell --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Zusammenfassend: Socket ist eine Kapselung des TCP/IP -Protokolls. Socket selbst ist kein Protokoll, sondern eine aufrufende Schnittstelle (API).
Dies bildet einige der grundlegendsten funktionalen Schnittstellen, die wir kennen, z. B. Erstellen, Hören, Verbinden, Akzeptieren, Senden, Lesen und Schreiben usw.
TCP/IP ist nur ein Protokollstapel, genau wie der Betriebsmechanismus des Betriebssystems muss er ausführlich implementiert werden und bietet auch externe Betriebsoberflächen.
Tatsächlich basiert der TCP der Transportschicht auf dem IP -Protokoll der Netzwerkschicht, und das HTTP -Protokoll der Anwendungsschicht basiert auf dem TCP -Protokoll der Transportschicht. Sockel selbst ist kein Protokoll. Wie oben erwähnt, bietet es nur eine Schnittstelle für TCP- oder UDP -Programmierung.
Zweitens erleben Sie es
Ok, wir haben das Konzept, nehen wir ein Beispiel:
1. erstellen server.js
Die Codekopie lautet wie folgt:
var net = require ('net');
var server = net.createserver (Funktion (c) {// Verbindungshörer
Console.log ("Server Connected");
c.on ("End", function () {
console.log ("Server wurde getrennt");
});
C.Write ("Hallo, Bigbear!/r/n");
C.Pipe (c);
});
server.Listen (8124, function () {// Listener hören
console.log ("Server gebunden");
});
2. CRESPENT CLESCE.JS
Die Codekopie lautet wie folgt:
var net = require ('net');
var client = net.connect ({{
Port: 8124
}, function () {// Listener verbinden
console.log ("client angeschlossen");
Client.Write ('Hallo, Baby!/R/N');
});
Client.on ("Daten", Funktion (Daten) {
console.log (data.toString ());
Client.end ();
});
client.on ("End", function () {
console.log ("Client -Disconnect");
});
Lassen Sie uns analysieren:
Server ------ net.createServer erstellt einen TCP-Dienst. Dieser Dienst ist auf dem Port 8124 gebunden (server.Listen). Nach dem Erstellen des Servers sehen wir eine Rückruffunktion.
Beim Aufrufen der obigen Funktion ist auch ein Parameter eine Funktion, und es akzeptiert Socket, eine von andere Methoden konstruierte Pipe, und seine Funktion dient der Dateninteraktion.
Pipe muss vom Kunden begrüßt werden, um ihn zu etablieren. Wenn derzeit kein Client -Zugriff auf den Server vorhanden ist, gibt es diesen Socket nicht.
Wie der Name schon sagt, ist客户端------net.connect mit dem Server verbunden. Der erste Parameter ist ein Objekt. Der Port (Port) ist auf 8124 eingestellt, wobei der Port, auf den unser Server hört. Da der Hostparameter nicht festgelegt ist, ist der Standardwert lokal (lokal).
Auf dem Server ist der Socket ein Ende der Pipeline, und im Client ist der Client selbst ein Ende der Pipeline. Wenn mehrere Clients mit dem Server verbunden sind, erstellt der Server mehrere Sockets und jeder Socket entspricht einem Client.
Auslaufergebnisse:
3. Falleinführung
(1) Der folgende Code ist nur der Server, der einen Text an den Client ausgibt, um die Einweg-Kommunikation vom Server zum Client zu vervollständigen.
Die Codekopie lautet wie folgt:
// Sever-> Einweg-Kommunikation des Kunden
var net = require ('net');
var chatserver = net.createServer ();
chatserver.on ('Verbindung', Funktion (Client) {
client.write ('hi!/n'); // Der Server gibt Informationen an den Client aus und verwendet die Write () -Methode
client.write ('bye!/n');
Client.end (); // Der Server beendet die Sitzung
});
chatserver.listen (9000);
Telnet -Test: Telnet127.0.0.1: 9000
Nachdem Sie Telnet ausgeführt haben, stellen Sie eine Verbindung zum Servicepunkt her, Feedback die Charaktere von HI! Tschüss! Und beenden Sie sofort das Serverprogramm und beenden Sie die Verbindung.
Was ist, wenn wir möchten, dass der Server eine Verbindung zu den Informationen zum Client herstellt?
Sie können das Ereignis von Server.Data anhören und die Verbindung nicht abbrechen (oder es wird sofort Nachrichten vom Client beendet, die nicht akzeptiert werden können).
(2) Hören Sie sich das Ereignis von Server.Data an und lassen Sie die Verbindung nicht ab (ansonsten können Nachrichten vom Client nicht sofort akzeptiert werden).
Die Codekopie lautet wie folgt:
// Basierend auf dem ersteren implementieren Sie Client-> Sever-Kommunikation, die eine wechselseitige Kommunikation ist
var net = require ('net');
var chatserver = net.createServer (),
ClientList = [];
chatserver.on ('Verbindung', Funktion (Client) {
// js kann Objekten frei addieren. Hier fügen wir ein benutzerdefiniertes Namensattribut des Namens hinzu, um anzugeben, auf welchem Client der Client des Clients der Client basiert)
client.name = client.remoteaddress + ':' + client.remoteport;
client.write ('hi' + client.name + '!/n');
ClientList.push (Client);
client.on ('Daten', Funktion (Daten) {
Broadcast (Daten, Client); // Informationen vom Client akzeptieren
});
});
Funktionsübertragung (Nachricht, Client) {
für (var i = 0; i <clientlist.length; i+= 1) {
if (Client! == ClientList [i]) {
ClientList [i] .Write (client.name + "sagt" + meldung);
}
}
}
chatserver.listen (9000);
Ist der obige Code ein vollständiger Code? Wir sagten, es gibt ein anderes Problem, das nicht berücksichtigt wurde: Sobald ein Kunde beendet ist, bleibt er in der Clientlist, was offensichtlich ein Nullzeiger ist.
(3) Process ClientList
Die Codekopie lautet wie folgt:
chatserver.on ('Verbindung', Funktion (Client) {
client.name = client.remoteaddress + ':' + client.remoteport
client.write ('hi' + client.name + '!/n');
Clientlist.push (Client)
client.on ('Daten', Funktion (Daten) {
Sendung (Daten, Client)
})
client.on ('end', function () {
ClientList.SPLICE (ClientList.indexof (Client), 1); // Löschen Sie das Formelelement im Array.
})
})
NodetCpapi hat uns ein End -Ereignis zur Verfügung gestellt, dh wenn der Client die Verbindung zum Server abbricht.
(4) Sendung optimieren
Die Codekopie lautet wie folgt:
Funktionsübertragung (Nachricht, Client) {
var slealup = []
für (var i = 0; i <clientlist.length; i+= 1) {
if (Client! == ClientList [i]) {
if (ClientList [i] .Wrable) {// Überprüfen Sie, ob Sockets zuerst beschreibbar sind
ClientList [i] .Write (Client.Name + "sagt" + Nachricht)
} anders {
CleanUp.push (ClientList [i]) // Wenn es nicht beschreibbar ist, sammeln und zerstören Sie es. Vor der Zerstörung sollte Socket.Destroy () durch API zerstört werden.
Clientlist [i] .Destroy ()
}
}
} // Entfernen Sie tote Knoten aus der Schreibschleife, um den Müllschleifenindex zu vermeiden
für (i = 0; i <cleanup.length; i+= 1) {
ClientList.splice (ClientList.Indexof (Reinigung [i]), 1)
}
}
Beachten Sie, dass eine Ausnahme, sobald das Ende "Ende" ausgelöst wird, eine Ausnahme erfolgt, sodass die Optimierungsarbeiten durchgeführt werden.
(5) NetAPI bietet auch ein Fehlerereignis zum Fangen von Client -Ausnahmen
Die Codekopie lautet wie folgt:
Client.on ('Fehler', Funktion (e) {
console.log (e);
});
Vier, lasst uns zusammenfassen
1. Verstehen Sie die relevanten Konzepte des Anfangs
2. Verstehen Sie die Beziehung zwischen HTTP- und NET -Modulen
3. Basierend auf den Beispielen in diesem Artikel finden Sie in den zuständigen APIs zur Praxis.
4. Kommunikationsideen zwischen Socket -Client und Server
5. Wenn Sie interessiert sind, können Sie das Beispiel dieses Chatraums verbessern